Rename WhatsAppWeb to WhatsApp

25 files changed, 232920 insertions, 0 deletions

diff --git a/protocols/WhatsApp/src/avatars.cpp b/protocols/WhatsApp/src/avatars.cpp
new file mode 100644
index 0000000000..09a693a0d0
--- /dev/null
+++ b/protocols/WhatsApp/src/avatars.cpp
@@ -0,0 +1,158 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+void WhatsAppProto::OnGetAvatarInfo(const JSONNode &root, void *pUserInfo)
+{
+	if (!root) return;
+
+	MCONTACT hContact = (UINT_PTR)pUserInfo;
+
+	PROTO_AVATAR_INFORMATION ai = {};
+	ai.hContact = hContact;
+	ai.format = PA_FORMAT_JPEG;
+	wcsncpy_s(ai.filename, GetAvatarFileName(hContact), _TRUNCATE);
+
+	DWORD dwLastChangeTime = _wtoi(root["tag"].as_mstring());
+
+	CMStringA szUrl(root["eurl"].as_mstring());
+	if (szUrl.IsEmpty()) {
+		setDword(hContact, DBKEY_AVATAR_TAG, 0); // avatar doesn't exist, don't check it later
+
+LBL_Error:
+		ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_FAILED, HANDLE(&ai));
+		return;
+	}
+
+	// if avatar was changed or not present at all, download it
+	if (dwLastChangeTime > getDword(hContact, DBKEY_AVATAR_TAG)) {
+		if (!g_plugin.SaveFile(szUrl, ai))
+			goto LBL_Error;
+
+		// set timestamp of avatar being saved
+		setDword(hContact, DBKEY_AVATAR_TAG, dwLastChangeTime);
+	}
+	ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, HANDLE(&ai));
+}
+
+INT_PTR WhatsAppProto::GetAvatarInfo(WPARAM wParam, LPARAM lParam)
+{
+	PROTO_AVATAR_INFORMATION *pai = (PROTO_AVATAR_INFORMATION*)lParam;
+
+	ptrA id(getStringA(pai->hContact, isChatRoom(pai->hContact) ? "ChatRoomID" : DBKEY_JID));
+	if (id == NULL)
+		return GAIR_NOAVATAR;
+
+	CMStringW tszFileName(GetAvatarFileName(pai->hContact));
+	wcsncpy_s(pai->filename, tszFileName.c_str(), _TRUNCATE);
+	pai->format = PA_FORMAT_JPEG;
+
+	DWORD dwTag = getDword(pai->hContact, DBKEY_AVATAR_TAG, -1);
+	if (dwTag == -1 || (wParam & GAIF_FORCE) != 0)
+		if (pai->hContact != NULL && isOnline()) {
+			// WSSend(CMStringA(FORMAT, "[\"query\",\"ProfilePicThumb\",\"%s\"]", id.get()), &WhatsAppProto::OnGetAvatarInfo, (void*)pai->hContact);
+			return GAIR_WAITFOR;
+		}
+
+	debugLogA("No avatar");
+	return GAIR_NOAVATAR;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+INT_PTR WhatsAppProto::GetAvatarCaps(WPARAM wParam, LPARAM lParam)
+{
+	switch (wParam) {
+	case AF_PROPORTION:
+		return PIP_SQUARE;
+
+	case AF_FORMATSUPPORTED: // Jabber supports avatars of virtually all formats
+		return PA_FORMAT_JPEG;
+
+	case AF_ENABLED:
+		return TRUE;
+
+	case AF_MAXSIZE:
+		POINT *size = (POINT*)lParam;
+		if (size)
+			size->x = size->y = 640;
+		return 0;
+	}
+	return -1;
+}
+
+CMStringW WhatsAppProto::GetAvatarFileName(MCONTACT hContact)
+{
+	CMStringW result = m_tszAvatarFolder + L"\\";
+
+	CMStringA jid;
+	if (hContact != NULL) {
+		ptrA szId(getStringA(hContact, isChatRoom(hContact) ? "ChatRoomID" : DBKEY_JID));
+		if (szId == NULL)
+			return L"";
+
+		jid = szId;
+	}
+	else jid = m_szJid;
+
+	return result + _A2T(jid.c_str()) + L".jpg";
+}
+
+INT_PTR WhatsAppProto::GetMyAvatar(WPARAM wParam, LPARAM lParam)
+{
+	std::wstring tszOwnAvatar(m_tszAvatarFolder + L"\\myavatar.jpg");
+	wcsncpy_s((wchar_t*)wParam, lParam, tszOwnAvatar.c_str(), _TRUNCATE);
+	return 0;
+}
+
+INT_PTR WhatsAppProto::SetMyAvatar(WPARAM, LPARAM)
+{
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+bool CMPlugin::SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai)
+{
+	NETLIBHTTPREQUEST req = {};
+	req.cbSize = sizeof(req);
+	req.flags = NLHRF_NODUMP | NLHRF_PERSISTENT | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT;
+	req.requestType = REQUEST_GET;
+	req.szUrl = (char*)pszUrl;
+	req.nlc = hAvatarConn;
+
+	NETLIBHTTPREQUEST *pReply = Netlib_HttpTransaction(hAvatarUser, &req);
+	if (pReply == nullptr) {
+		hAvatarConn = nullptr;
+		debugLogA("Failed to retrieve avatar from url: %s", pszUrl);
+		return false;
+	}
+
+	hAvatarConn = pReply->nlc;
+
+	bool bSuccess = false;
+	if (pReply->resultCode == 200 && pReply->pData && pReply->dataLength) {
+		if (auto *pszHdr = Netlib_GetHeader(pReply, "Content-Type"))
+			ai.format = ProtoGetAvatarFormatByMimeType(pszHdr);
+
+		if (ai.format != PA_FORMAT_UNKNOWN) {
+			FILE *fout = _wfopen(ai.filename, L"wb");
+			if (fout) {
+				fwrite(pReply->pData, 1, pReply->dataLength, fout);
+				fclose(fout);
+				bSuccess = true;
+			}
+			else debugLogA("Error saving avatar to file %S", ai.filename);
+		}
+		else debugLogA("unknown avatar mime type");
+	}
+	else debugLogA("Error %d reading avatar from url: %s", pReply->resultCode, pszUrl);
+
+	Netlib_FreeHttpRequest(pReply);
+	return bSuccess;
+}
diff --git a/protocols/WhatsApp/src/chats.cpp b/protocols/WhatsApp/src/chats.cpp
new file mode 100644
index 0000000000..3df2a954ee
--- /dev/null
+++ b/protocols/WhatsApp/src/chats.cpp
@@ -0,0 +1,99 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+void WhatsAppProto::InitChat(WAUser *pUser)
+{
+	CMStringA jid = "";
+	CMStringW wszId(Utf2T(jid.c_str())), wszNick(Utf2T(""));
+
+	setWString(pUser->hContact, "Nick", wszNick);
+
+	pUser->si = Chat_NewSession(GCW_CHATROOM, m_szModuleName, wszId, wszNick);
+
+	Chat_AddGroup(pUser->si, TranslateT("Owner"));
+	Chat_AddGroup(pUser->si, TranslateT("SuperAdmin"));
+	Chat_AddGroup(pUser->si, TranslateT("Admin"));
+	Chat_AddGroup(pUser->si, TranslateT("Participant"));
+
+	Chat_Control(m_szModuleName, wszId, m_bHideGroupchats ? WINDOW_HIDDEN : SESSION_INITDONE);
+	Chat_Control(m_szModuleName, wszId, SESSION_ONLINE);
+
+	if (!pUser->bInited) {
+		// CMStringA query(FORMAT, "[\"query\",\"GroupMetadata\",\"%s\"]", jid.c_str());
+		// WSSend(query, &WhatsAppProto::OnGetChatInfo, pUser);
+	}
+}
+
+void WhatsAppProto::OnGetChatInfo(const JSONNode &root, void *param)
+{
+	auto *pChatUser = (WAUser *)param;
+	pChatUser->bInited = true;
+
+	CMStringW wszOwner(root["owner"].as_mstring()), wszNick;
+
+	for (auto &it : root["participants"]) {
+		CMStringW jid(it["id"].as_mstring());
+		CMStringA szJid(jid);
+
+		GCEVENT gce = { m_szModuleName, 0, GC_EVENT_JOIN };
+		gce.pszID.w = pChatUser->si->ptszID;
+		gce.pszUID.w = jid;
+		gce.bIsMe = (szJid == m_szJid);
+
+		if (jid == wszOwner)
+			gce.pszStatus.w = L"Owner";
+		else if (it["isSuperAdmin"].as_bool())
+			gce.pszStatus.w = L"SuperAdmin";
+		else if (it["isAdmin"].as_bool())
+			gce.pszStatus.w = L"Admin";
+		else
+			gce.pszStatus.w = L"Participant";
+
+		if (gce.bIsMe)
+			wszNick = getMStringW(DBKEY_NICK);
+		else if (auto *pUser = FindUser(szJid))
+			wszNick = Clist_GetContactDisplayName(pUser->hContact);
+		else {
+			int iPos = jid.Find('@');
+			wszNick = (iPos != -1) ? jid.Left(iPos - 1) : jid;
+		}
+
+		gce.pszNick.w = wszNick;
+		Chat_Event(&gce);
+	}
+
+	if (pChatUser->arHistory.getCount()) {
+		for (auto &it : pChatUser->arHistory) {
+			CMStringW jid(it->jid), text(Utf2T(it->text));
+
+			GCEVENT gce = { m_szModuleName, 0, GC_EVENT_MESSAGE };
+			gce.pszID.w = pChatUser->si->ptszID;
+			gce.dwFlags = GCEF_ADDTOLOG;
+			gce.pszUID.w = jid;
+			gce.pszText.w = text;
+			gce.time = it->timestamp;
+			gce.bIsMe = (it->jid == m_szJid);
+			Chat_Event(&gce);
+		}
+		pChatUser->arHistory.destroy();
+	}
+
+	CMStringW wszSubject(root["subject"].as_mstring());
+	if (!wszSubject.IsEmpty()) {
+		time_t iSubjectTime(root["subjectTime"].as_int());
+		CMStringW wszSubjectSet(root["subjectOwner"].as_mstring());
+
+		GCEVENT gce = { m_szModuleName, 0, GC_EVENT_TOPIC };
+		gce.pszID.w	 = pChatUser->si->ptszID;
+		gce.pszUID.w = wszSubjectSet;
+		gce.pszText.w = wszSubject;
+		gce.time = iSubjectTime;
+		Chat_Event(&gce);
+	}
+}
diff --git a/protocols/WhatsApp/src/crypt.cpp b/protocols/WhatsApp/src/crypt.cpp
new file mode 100644
index 0000000000..09a14f53b0
--- /dev/null
+++ b/protocols/WhatsApp/src/crypt.cpp
@@ -0,0 +1,140 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+MBinBuffer aesDecrypt(
+	const EVP_CIPHER *cipher,
+	const uint8_t *key, 
+	const uint8_t *iv,
+	const void *data, size_t dataLen,
+	const void *additionalData, size_t additionalLen)
+{
+	int tag_len = 0, dec_len = 0, final_len = 0;
+	EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+	EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv);
+
+	if (additionalLen)
+		EVP_DecryptUpdate(ctx, nullptr, &tag_len, (uint8_t *)additionalData, (int)additionalLen);
+
+	dataLen -= 16;
+	EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, (uint8_t *)data + dataLen);
+
+	MBinBuffer ret;
+	uint8_t outbuf[2000];
+	for (size_t len = 0; len < dataLen; len += 1024) {
+		size_t portionSize = dataLen - len;
+		EVP_DecryptUpdate(ctx, outbuf, &dec_len, (uint8_t *)data + len, (int)min(portionSize, 1024));
+		ret.append(outbuf, dec_len);
+	}
+
+	EVP_DecryptFinal_ex(ctx, outbuf, &final_len);
+	if (final_len)
+		ret.append(outbuf, final_len);
+
+	EVP_CIPHER_CTX_free(ctx);
+	return ret;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static unsigned char *HKDF_Extract(const EVP_MD *evp_md,
+	const unsigned char *salt, size_t salt_len,
+	const unsigned char *key, size_t key_len,
+	unsigned char *prk, size_t *prk_len)
+{
+	unsigned int tmp_len;
+
+	if (!HMAC(evp_md, salt, (int)salt_len, key, (int)key_len, prk, &tmp_len))
+		return NULL;
+
+	*prk_len = tmp_len;
+	return prk;
+}
+
+static unsigned char *HKDF_Expand(const EVP_MD *evp_md,
+	const unsigned char *prk, size_t prk_len,
+	const unsigned char *info, size_t info_len,
+	unsigned char *okm, size_t okm_len)
+{
+	HMAC_CTX *hmac;
+	unsigned char *ret = NULL;
+
+	unsigned int i;
+
+	unsigned char prev[EVP_MAX_MD_SIZE];
+
+	size_t done_len = 0, dig_len = EVP_MD_size(evp_md);
+
+	size_t n = okm_len / dig_len;
+	if (okm_len % dig_len)
+		n++;
+
+	if (n > 255 || okm == NULL)
+		return NULL;
+
+	if ((hmac = HMAC_CTX_new()) == NULL)
+		return NULL;
+
+	if (!HMAC_Init_ex(hmac, prk, (int)prk_len, evp_md, NULL))
+		goto err;
+
+	for (i = 1; i <= n; i++) {
+		size_t copy_len;
+		const unsigned char ctr = i;
+
+		if (i > 1) {
+			if (!HMAC_Init_ex(hmac, NULL, 0, NULL, NULL))
+				goto err;
+
+			if (!HMAC_Update(hmac, prev, dig_len))
+				goto err;
+		}
+
+		if (!HMAC_Update(hmac, info, info_len))
+			goto err;
+
+		if (!HMAC_Update(hmac, &ctr, 1))
+			goto err;
+
+		if (!HMAC_Final(hmac, prev, NULL))
+			goto err;
+
+		copy_len = (done_len + dig_len > okm_len) ?
+			okm_len - done_len :
+			dig_len;
+
+		memcpy(okm + done_len, prev, copy_len);
+
+		done_len += copy_len;
+	}
+	ret = okm;
+
+err:
+	OPENSSL_cleanse(prev, sizeof(prev));
+	HMAC_CTX_free(hmac);
+	return ret;
+}
+
+unsigned char *HKDF(const EVP_MD *evp_md,
+	const unsigned char *salt, size_t salt_len,
+	const unsigned char *key, size_t key_len,
+	const unsigned char *info, size_t info_len,
+	unsigned char *okm, size_t okm_len)
+{
+	unsigned char prk[EVP_MAX_MD_SIZE];
+	unsigned char *ret;
+	size_t prk_len;
+
+	if (!HKDF_Extract(evp_md, salt, salt_len, key, key_len, prk, &prk_len))
+		return NULL;
+
+	ret = HKDF_Expand(evp_md, prk, prk_len, info, info_len, okm, okm_len);
+	OPENSSL_cleanse(prk, sizeof(prk));
+
+	return ret;
+}
diff --git a/protocols/WhatsApp/src/db.h b/protocols/WhatsApp/src/db.h
new file mode 100644
index 0000000000..c8cb6e249c
--- /dev/null
+++ b/protocols/WhatsApp/src/db.h
@@ -0,0 +1,43 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#define MODULENAME  "WhatsApp"
+
+// DB keys
+#define DBKEY_JID                     "jid"
+#define DBKEY_DEVICE_ID               "DeviceId"
+#define DBKEY_EPHEMERAL_TS            "EphemeralTS"
+#define DBKEY_EPHEMERAL_EXPIRE        "EphemeralExpire"
+
+#define DBKEY_NOISE_PUB               "NoisePublicKey"
+#define DBKEY_NOISE_PRIV              "NoisePrivateKey"
+
+#define DBKEY_SIGNED_IDENTITY_PUB     "SignedIdentityPublicKey"
+#define DBKEY_SIGNED_IDENTITY_PRIV    "SignedIdentityPrivateKey"
+
+#define DBKEY_PREKEY                  "SignedPreKey0"
+#define DBKEY_PREKEY_NEXT_ID          "PrekeyNextId"
+#define DBKEY_PREKEY_UPLOAD_ID        "PrekeyUploadId"
+
+#define DBKEY_REG_ID                  "RegistrationId"
+#define DBKEY_SECRET_KEY              "AdvSecretKey"
+
+#define DBKEY_NICK                    "Nick"
+#define DBKEY_DEF_GROUP               "DefaultGroup"
+#define DBKEY_AUTORUNCHATS            "AutoRunChats"
+#define DBKEY_AVATAR_TAG              "AvatarTag"
+
+#define DBKEY_EVENT_CLIENT_COLBACK    "PopupClientColorBack"
+#define DBKEY_EVENT_CLIENT_COLTEXT    "PopupClientColorText"
+#define DBKEY_EVENT_CLIENT_TIMEOUT    "PopupClientTimeout"
+#define DBKEY_EVENT_CLIENT_DEFAULT    "PopupClientColorDefault"
+
+#define DBKEY_EVENT_OTHER_COLBACK     "PopupOtherColorBack"
+#define DBKEY_EVENT_OTHER_COLTEXT     "PopupOtherColorText"
+#define DBKEY_EVENT_OTHER_TIMEOUT     "PopupOtherTimeout"
+#define DBKEY_EVENT_OTHER_DEFAULT     "PopupOtherColorDefault"
+
diff --git a/protocols/WhatsApp/src/dicts.h b/protocols/WhatsApp/src/dicts.h
new file mode 100644
index 0000000000..7b84487d14
--- /dev/null
+++ b/protocols/WhatsApp/src/dicts.h
@@ -0,0 +1,194 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+static char *SingleByteTokens[] = {
+	"", "xmlstreamstart", "xmlstreamend", "s.whatsapp.net", "type", "participant", "from", "receipt", "id", "broadcast", "status", "message", "notification", "notify", "to", "jid", "user", 
+	"class", "offline", "g.us", "result", "mediatype", "enc", "skmsg", "off_cnt", "xmlns", "presence", "participants", "ack", "t", "iq", "device_hash", "read", "value", "media", "picture",
+	"chatstate", "unavailable", "text", "urn:xmpp:whatsapp:push", "devices", "verified_name", "contact", "composing", "edge_routing", "routing_info", "item", "image", "verified_level", 
+	"get", "fallback_hostname", "2", "media_conn", "1", "v", "handshake", "fallback_class", "count", "config", "offline_preview", "download_buckets", "w:profile:picture", "set", 
+	"creation", "location", "fallback_ip4", "msg", "urn:xmpp:ping", "fallback_ip6", "call-creator", "relaylatency", "success", "subscribe", "video", "business_hours_config", 
+	"platform", "hostname", "version", "unknown", "0", "ping", "hash", "edit", "subject", "max_buckets", "download", "delivery", "props", "sticker", "name", "last", "contacts", 
+	"business", "primary", "preview", "w:p", "pkmsg", "call-id", "retry", "prop", "call", "auth_ttl", "available", "relay_id", "last_id", "day_of_week", "w", "host", "seen", 
+	"bits", "list", "atn", "upload", "is_new", "w:stats", "key", "paused", "specific_hours", "multicast", "stream:error", "mmg.whatsapp.net", "code", "deny", "played", "profile", 
+	"fna", "device-list", "close_time", "latency", "gcm", "pop", "audio", "26", "w:web", "open_time", "error", "auth", "ip4", "update", "profile_options", "config_value", "category",
+	"catalog_not_created", "00", "config_code", "mode", "catalog_status", "ip6", "blocklist", "registration", "7", "web", "fail", "w:m", "cart_enabled", "ttl", "gif", "300", 
+	"device_orientation", "identity", "query", "401", "media-gig2-1.cdn.whatsapp.net", "in", "3", "te2", "add", "fallback", "categories", "ptt", "encrypt", "notice", 
+	"thumbnail-document", "item-not-found", "12", "thumbnail-image", "stage", "thumbnail-link", "usync", "out", "thumbnail-video", "8", "01", "context", "sidelist", 
+	"thumbnail-gif", "terminate", "not-authorized", "orientation", "dhash", "capability", "side_list", "md-app-state", "description", "serial", "readreceipts", "te", 
+	"business_hours", "md-msg-hist", "tag", "attribute_padding", "document", "open_24h", "delete", "expiration", "active", "prev_v_id", "true", "passive", "index", "4", 
+	"conflict", "remove", "w:gp2", "config_expo_key", "screen_height", "replaced", "02", "screen_width", "uploadfieldstat", "2:47DEQpj8", "media-bog1-1.cdn.whatsapp.net", 
+	"encopt", "url", "catalog_exists", "keygen", "rate", "offer", "opus", "media-mia3-1.cdn.whatsapp.net", "privacy", "media-mia3-2.cdn.whatsapp.net", "signature", 
+	"preaccept", "token_id", "media-eze1-1.cdn.whatsapp.net"
+};
+
+static char *dict0[] = {
+	"media-for1-1.cdn.whatsapp.net", "relay", "media-gru2-2.cdn.whatsapp.net", "uncompressed", "medium", "voip_settings", "device", "reason",
+	"media-lim1-1.cdn.whatsapp.net", "media-qro1-2.cdn.whatsapp.net", "media-gru1-2.cdn.whatsapp.net", "action", "features", "media-gru2-1.cdn.whatsapp.net",
+	"media-gru1-1.cdn.whatsapp.net", "media-otp1-1.cdn.whatsapp.net", "kyc-id", "priority", "phash", "mute", "token", "100", "media-qro1-1.cdn.whatsapp.net",
+	"none", "media-mrs2-2.cdn.whatsapp.net", "sign_credential", "03", "media-mrs2-1.cdn.whatsapp.net", "protocol", "timezone", "transport", "eph_setting", "1080",
+	"original_dimensions", "media-frx5-1.cdn.whatsapp.net", "background", "disable", "original_image_url", "5", "transaction-id", "direct_path", "103", "appointment_only",
+	"request_image_url", "peer_pid", "address", "105", "104", "102", "media-cdt1-1.cdn.whatsapp.net", "101", "109", "110", "106", "background_location", "v_id", "sync",
+	"status-old", "111", "107", "ppic", "media-scl2-1.cdn.whatsapp.net", "business_profile", "108", "invite", "04", "audio_duration", "media-mct1-1.cdn.whatsapp.net",
+	"media-cdg2-1.cdn.whatsapp.net", "media-los2-1.cdn.whatsapp.net", "invis", "net", "voip_payload_type", "status-revoke-delay", "404", "state", "use_correct_order_for_hmac_sha1",
+	"ver", "media-mad1-1.cdn.whatsapp.net", "order", "540", "skey", "blinded_credential", "android", "contact_remove", "enable_downlink_relay_latency_only", "duration",
+	"enable_vid_one_way_codec_nego", "6", "media-sof1-1.cdn.whatsapp.net", "accept", "all", "signed_credential", "media-atl3-1.cdn.whatsapp.net", "media-lhr8-1.cdn.whatsapp.net",
+	"website", "05", "latitude", "media-dfw5-1.cdn.whatsapp.net", "forbidden", "enable_audio_piggyback_network_mtu_fix", "media-dfw5-2.cdn.whatsapp.net", "note.m4r",
+	"media-atl3-2.cdn.whatsapp.net", "jb_nack_discard_count_fix", "longitude", "Opening.m4r", "media-arn2-1.cdn.whatsapp.net", "email", "timestamp", "admin",
+	"media-pmo1-1.cdn.whatsapp.net", "America/Sao_Paulo", "contact_add", "media-sin6-1.cdn.whatsapp.net", "interactive", "8000", "acs_public_key",
+	"sigquit_anr_detector_release_rollover_percent", "media.fmed1-2.fna.whatsapp.net", "groupadd", "enabled_for_video_upgrade", "latency_update_threshold",
+	"media-frt3-2.cdn.whatsapp.net", "calls_row_constraint_layout", "media.fgbb2-1.fna.whatsapp.net", "mms4_media_retry_notification_encryption_enabled", "timeout",
+	"media-sin6-3.cdn.whatsapp.net", "audio_nack_jitter_multiplier", "jb_discard_count_adjust_pct_rc", "audio_reserve_bps", "delta", "account_sync", "default",
+	"media.fjed4-6.fna.whatsapp.net", "06", "lock_video_orientation", "media-frt3-1.cdn.whatsapp.net", "w:g2", "media-sin6-2.cdn.whatsapp.net", "audio_nack_algo_mask",
+	"media.fgbb2-2.fna.whatsapp.net", "media.fmed1-1.fna.whatsapp.net", "cond_range_target_bitrate", "mms4_server_error_receipt_encryption_enabled", "vid_rc_dyn", "fri", 
+	"cart_v1_1_order_message_changes_enabled", "reg_push", "jb_hist_deposit_value", "privatestats", "media.fist7-2.fna.whatsapp.net", "thu", "jb_discard_count_adjust_pct", 
+	"mon", "group_call_video_maximization_enabled", "mms_cat_v1_forward_hot_override_enabled", "audio_nack_new_rtt", "media.fsub2-3.fna.whatsapp.net",
+	"media_upload_aggressive_retry_exponential_backoff_enabled", "tue", "wed", "media.fruh4-2.fna.whatsapp.net", "audio_nack_max_seq_req", "max_rtp_audio_packet_resends",
+	"jb_hist_max_cdf_value", "07", "audio_nack_max_jb_delay", "mms_forward_partially_downloaded_video", "media-lcy1-1.cdn.whatsapp.net", "resume", "jb_inband_fec_aware", 
+	"new_commerce_entry_point_enabled", "480", "payments_upi_generate_qr_amount_limit", "sigquit_anr_detector_rollover_percent", "media.fsdu2-1.fna.whatsapp.net", "fbns",
+	"aud_pkt_reorder_pct", "dec", "stop_probing_before_accept_send", "media_upload_max_aggressive_retries", "edit_business_profile_new_mode_enabled", 
+	"media.fhex4-1.fna.whatsapp.net", "media.fjed4-3.fna.whatsapp.net", "sigquit_anr_detector_64bit_rollover_percent", "cond_range_ema_jb_last_delay", 
+	"watls_enable_early_data_http_get", "media.fsdu2-2.fna.whatsapp.net", "message_qr_disambiguation_enabled", "media-mxp1-1.cdn.whatsapp.net", "sat", "vertical", 
+	"media.fruh4-5.fna.whatsapp.net", "200", "media-sof1-2.cdn.whatsapp.net", "-1", "height", "product_catalog_hide_show_items_enabled", "deep_copy_frm_last", 
+	"tsoffline", "vp8/h.264", "media.fgye5-3.fna.whatsapp.net", "media.ftuc1-2.fna.whatsapp.net", "smb_upsell_chat_banner_enabled", "canonical", "08", "9", ".", 
+	"media.fgyd4-4.fna.whatsapp.net", "media.fsti4-1.fna.whatsapp.net", "mms_vcache_aggregation_enabled", "mms_hot_content_timespan_in_seconds", "nse_ver", "rte", 
+	"third_party_sticker_web_sync", "cond_range_target_total_bitrate", "media_upload_aggressive_retry_enabled", "instrument_spam_report_enabled", "disable_reconnect_tone", 
+	"move_media_folder_from_sister_app", "one_tap_calling_in_group_chat_size", "10", "storage_mgmt_banner_threshold_mb", "enable_backup_passive_mode", "sharechat_inline_player_enabled", 
+	"media.fcnq2-1.fna.whatsapp.net", "media.fhex4-2.fna.whatsapp.net", "media.fist6-3.fna.whatsapp.net", "ephemeral_drop_column_stage", "reconnecting_after_network_change_threshold_ms", 
+	"media-lhr8-2.cdn.whatsapp.net", "cond_jb_last_delay_ema_alpha", "entry_point_block_logging_enabled", "critical_event_upload_log_config", "respect_initial_bitrate_estimate", 
+	"smaller_image_thumbs_status_enabled", "media.fbtz1-4.fna.whatsapp.net", "media.fjed4-1.fna.whatsapp.net", "width", "720", "enable_frame_dropper", "enable_one_side_mode", 
+	"urn:xmpp:whatsapp:dirty", "new_sticker_animation_behavior_v2", "media.flim3-2.fna.whatsapp.net", "media.fuio6-2.fna.whatsapp.net", "skip_forced_signaling", "dleq_proof", 
+	"status_video_max_bitrate", "lazy_send_probing_req", "enhanced_storage_management", "android_privatestats_endpoint_dit_enabled", "media.fscl13-2.fna.whatsapp.net", "video_duration"
+};
+
+static char *dict1[] = {
+	"group_call_discoverability_enabled", "media.faep9-2.fna.whatsapp.net", "msgr", "bloks_loggedin_access_app_id", "db_status_migration_step", "watls_prefer_ip6", 
+	"jabber:iq:privacy", "68", "media.fsaw1-11.fna.whatsapp.net", "mms4_media_conn_persist_enabled", "animated_stickers_thread_clean_up", "media.fcgk3-2.fna.whatsapp.net", 
+	"media.fcgk4-6.fna.whatsapp.net", "media.fgye5-2.fna.whatsapp.net", "media.flpb1-1.fna.whatsapp.net", "media.fsub2-1.fna.whatsapp.net", "media.fuio6-3.fna.whatsapp.net", 
+	"not-allowed", "partial_pjpeg_bw_threshold", "cap_estimated_bitrate", "mms_chatd_resume_check_over_thrift", "smb_upsell_business_profile_enabled", "product_catalog_webclient", 
+	"groups", "sigquit_anr_detector_release_updated_rollout", "syncd_key_rotation_enabled", "media.fdmm2-1.fna.whatsapp.net", "media-hou1-1.cdn.whatsapp.net", 
+	"remove_old_chat_notifications", "smb_biztools_deeplink_enabled", "use_downloadable_filters_int", "group_qr_codes_enabled", "max_receipt_processing_time", 
+	"optimistic_image_processing_enabled", "smaller_video_thumbs_status_enabled", "watls_early_data", "reconnecting_before_relay_failover_threshold_ms", "cond_range_packet_loss_pct", 
+	"groups_privacy_blacklist", "status-revoke-drop", "stickers_animated_thumbnail_download", "dedupe_transcode_shared_images", "dedupe_transcode_shared_videos", 
+	"media.fcnq2-2.fna.whatsapp.net", "media.fgyd4-1.fna.whatsapp.net", "media.fist7-1.fna.whatsapp.net", "media.flim3-3.fna.whatsapp.net", "add_contact_by_qr_enabled", 
+	"https://faq.whatsapp.com/payments", "multicast_limit_global", "sticker_notification_preview", "smb_better_catalog_list_adapters_enabled", "bloks_use_minscript_android",
+	"pen_smoothing_enabled", "media.fcgk4-5.fna.whatsapp.net", "media.fevn1-3.fna.whatsapp.net", "media.fpoj7-1.fna.whatsapp.net", "media-arn2-2.cdn.whatsapp.net", 
+	"reconnecting_before_network_change_threshold_ms", "android_media_use_fresco_for_gifs", "cond_in_congestion", "status_image_max_edge", "sticker_search_enabled", 
+	"starred_stickers_web_sync", "db_blank_me_jid_migration_step", "media.fist6-2.fna.whatsapp.net", "media.ftuc1-1.fna.whatsapp.net", "09", "anr_fast_logs_upload_rollout", 
+	"camera_core_integration_enabled", "11", "third_party_sticker_caching", "thread_dump_contact_support", "wam_privatestats_enabled", "vcard_as_document_size_kb", "maxfpp",
+	"fbip", "ephemeral_allow_group_members", "media-bom1-2.cdn.whatsapp.net", "media-xsp1-1.cdn.whatsapp.net", "disable_prewarm", "frequently_forwarded_max", 
+	"media.fbtz1-5.fna.whatsapp.net", "media.fevn7-1.fna.whatsapp.net", "media.fgyd4-2.fna.whatsapp.net", "sticker_tray_animation_fully_visible_items", 
+	"green_alert_banner_duration", "reconnecting_after_p2p_failover_threshold_ms", "connected", "share_biz_vcard_enabled", "stickers_animation", "0a", "1200", "WhatsApp", 
+	"group_description_length", "p_v_id", "payments_upi_intent_transaction_limit", "frequently_forwarded_messages", "media-xsp1-2.cdn.whatsapp.net", 
+	"media.faep8-1.fna.whatsapp.net", "media.faep8-2.fna.whatsapp.net", "media.faep9-1.fna.whatsapp.net", "media.fdmm2-2.fna.whatsapp.net", "media.fgzt3-1.fna.whatsapp.net",
+	"media.flim4-2.fna.whatsapp.net", "media.frao1-1.fna.whatsapp.net", "media.fscl9-2.fna.whatsapp.net", "media.fsub2-2.fna.whatsapp.net", "superadmin", 
+	"media.fbog10-1.fna.whatsapp.net", "media.fcgh28-1.fna.whatsapp.net", "media.fjdo10-1.fna.whatsapp.net", "third_party_animated_sticker_import", "delay_fec", 
+	"attachment_picker_refresh", "android_linked_devices_re_auth_enabled", "rc_dyn", "green_alert_block_jitter", "add_contact_logging_enabled", "biz_message_logging_enabled", 
+	"conversation_media_preview_v2", "media-jnb1-1.cdn.whatsapp.net", "ab_key", "media.fcgk4-2.fna.whatsapp.net", "media.fevn1-1.fna.whatsapp.net", "media.fist6-1.fna.whatsapp.net", 
+	"media.fruh4-4.fna.whatsapp.net", "media.fsti4-2.fna.whatsapp.net", "mms_vcard_autodownload_size_kb", "watls_enabled", "notif_ch_override_off", "media.fsaw1-14.fna.whatsapp.net",
+	"media.fscl13-1.fna.whatsapp.net", "db_group_participant_migration_step", "1020", "cond_range_sterm_rtt", "invites_logging_enabled", "triggered_block_enabled", 
+	"group_call_max_participants", "media-iad3-1.cdn.whatsapp.net", "product_catalog_open_deeplink", "shops_required_tos_version", "image_max_kbytes", 
+	"cond_low_quality_vid_mode", "db_receipt_migration_step", "jb_early_prob_hist_shrink", "media.fdmm2-3.fna.whatsapp.net", "media.fdmm2-4.fna.whatsapp.net", 
+	"media.fruh4-1.fna.whatsapp.net", "media.fsaw2-2.fna.whatsapp.net", "remove_geolocation_videos", "new_animation_behavior", "fieldstats_beacon_chance", "403", 
+	"authkey_reset_on_ban", "continuous_ptt_playback", "reconnecting_after_relay_failover_threshold_ms", "false", "group", "sun", "conversation_swipe_to_reply", 
+	"ephemeral_messages_setting", "smaller_video_thumbs_enabled", "md_device_sync_enabled", "bloks_shops_pdp_url_regex", "lasso_integration_enabled", 
+	"media-bom1-1.cdn.whatsapp.net", "new_backup_format_enabled", "256", "media.faep6-1.fna.whatsapp.net", "media.fasr1-1.fna.whatsapp.net", "media.fbtz1-7.fna.whatsapp.net",
+	"media.fesb4-1.fna.whatsapp.net", "media.fjdo1-2.fna.whatsapp.net", "media.frba2-1.fna.whatsapp.net", "watls_no_dns", "600", "db_broadcast_me_jid_migration_step", 
+	"new_wam_runtime_enabled", "group_update", "enhanced_block_enabled", "sync_wifi_threshold_kb", "mms_download_nc_cat", "bloks_minification_enabled", 
+	"ephemeral_messages_enabled", "reject", "voip_outgoing_xml_signaling", "creator", "dl_bw", "payments_request_messages", "target_bitrate", "bloks_rendercore_enabled", 
+	"media-hbe1-1.cdn.whatsapp.net", "media-hel3-1.cdn.whatsapp.net", "media-kut2-2.cdn.whatsapp.net", "media-lax3-1.cdn.whatsapp.net", "media-lax3-2.cdn.whatsapp.net", 
+	"sticker_pack_deeplink_enabled", "hq_image_bw_threshold", "status_info", "voip", "dedupe_transcode_videos", "grp_uii_cleanup", "linked_device_max_count", 
+	"media.flim1-1.fna.whatsapp.net", "media.fsaw2-1.fna.whatsapp.net", "reconnecting_after_call_active_threshold_ms", "1140", "catalog_pdp_new_design", 
+	"media.fbtz1-10.fna.whatsapp.net", "media.fsaw1-15.fna.whatsapp.net", "0b", "consumer_rc_provider", "mms_async_fast_forward_ttl", "jb_eff_size_fix", 
+	"voip_incoming_xml_signaling", "media_provider_share_by_uuid", "suspicious_links", "dedupe_transcode_images", "green_alert_modal_start", "media-cgk1-1.cdn.whatsapp.net", 
+	"media-lga3-1.cdn.whatsapp.net", "template_doc_mime_types", "important_messages", "user_add", "vcard_max_size_kb", "media.fada2-1.fna.whatsapp.net", 
+	"media.fbog2-5.fna.whatsapp.net", "media.fbtz1-3.fna.whatsapp.net", "media.fcgk3-1.fna.whatsapp.net", "media.fcgk7-1.fna.whatsapp.net", "media.flim1-3.fna.whatsapp.net", 
+	"media.fscl9-1.fna.whatsapp.net", "ctwa_context_enterprise_enabled", "media.fsaw1-13.fna.whatsapp.net", "media.fuio11-2.fna.whatsapp.net", "status_collapse_muted", 
+	"db_migration_level_force", "recent_stickers_web_sync", "bloks_session_state", "bloks_shops_enabled", "green_alert_setting_deep_links_enabled", "restrict_groups", 
+	"battery", "green_alert_block_start", "refresh", "ctwa_context_enabled", "md_messaging_enabled", "status_image_quality", "md_blocklist_v2_server", 
+	"media-del1-1.cdn.whatsapp.net", "13", "userrate", "a_v_id", "cond_rtt_ema_alpha", "invalid"
+};
+
+static char *dict2[] = {
+	"media.fada1-1.fna.whatsapp.net", "media.fadb3-2.fna.whatsapp.net", "media.fbhz2-1.fna.whatsapp.net", "media.fcor2-1.fna.whatsapp.net", "media.fjed4-2.fna.whatsapp.net", 
+	"media.flhe4-1.fna.whatsapp.net", "media.frak1-2.fna.whatsapp.net", "media.fsub6-3.fna.whatsapp.net", "media.fsub6-7.fna.whatsapp.net", "media.fvvi1-1.fna.whatsapp.net", 
+	"search_v5_eligible", "wam_real_time_enabled", "report_disk_event", "max_tx_rott_based_bitrate", "product", "media.fjdo10-2.fna.whatsapp.net", "video_frame_crc_sample_interval", 
+	"media_max_autodownload", "15", "h.264", "wam_privatestats_buffer_count", "md_phash_v2_enabled", "account_transfer_enabled", "business_product_catalog", 
+	"enable_non_dyn_codec_param_fix", "is_user_under_epd_jurisdiction", "media.fbog2-4.fna.whatsapp.net", "media.fbtz1-2.fna.whatsapp.net", "media.fcfc1-1.fna.whatsapp.net", 
+	"media.fjed4-5.fna.whatsapp.net", "media.flhe4-2.fna.whatsapp.net", "media.flim1-2.fna.whatsapp.net", "media.flos5-1.fna.whatsapp.net", "android_key_store_auth_ver", 
+	"010", "anr_process_monitor", "delete_old_auth_key", "media.fcor10-3.fna.whatsapp.net", "storage_usage_enabled", "android_camera2_support_level", "dirty", 
+	"consumer_content_provider", "status_video_max_duration", "0c", "bloks_cache_enabled", "media.fadb2-2.fna.whatsapp.net", "media.fbko1-1.fna.whatsapp.net", 
+	"media.fbtz1-9.fna.whatsapp.net", "media.fcgk4-4.fna.whatsapp.net", "media.fesb4-2.fna.whatsapp.net", "media.fevn1-2.fna.whatsapp.net", "media.fist2-4.fna.whatsapp.net", 
+	"media.fjdo1-1.fna.whatsapp.net", "media.fruh4-6.fna.whatsapp.net", "media.fsrg5-1.fna.whatsapp.net", "media.fsub6-6.fna.whatsapp.net", "minfpp", "5000", "locales", 
+	"video_max_bitrate", "use_new_auth_key", "bloks_http_enabled", "heartbeat_interval", "media.fbog11-1.fna.whatsapp.net", "ephemeral_group_query_ts", "fec_nack", 
+	"search_in_storage_usage", "c", "media-amt2-1.cdn.whatsapp.net", "linked_devices_ui_enabled", "14", "async_data_load_on_startup", "voip_incoming_xml_ack", "16", 
+	"db_migration_step", "init_bwe", "max_participants", "wam_buffer_count", "media.fada2-2.fna.whatsapp.net", "media.fadb3-1.fna.whatsapp.net", "media.fcor2-2.fna.whatsapp.net", 
+	"media.fdiy1-2.fna.whatsapp.net", "media.frba3-2.fna.whatsapp.net", "media.fsaw2-3.fna.whatsapp.net", "1280", "status_grid_enabled", "w:biz", "product_catalog_deeplink", 
+	"media.fgye10-2.fna.whatsapp.net", "media.fuio11-1.fna.whatsapp.net", "optimistic_upload", "work_manager_init", "lc", "catalog_message", "cond_net_medium", 
+	"enable_periodical_aud_rr_processing", "cond_range_ema_rtt", "media-tir2-1.cdn.whatsapp.net", "frame_ms", "group_invite_sending", "payments_web_enabled", 
+	"wallpapers_v2", "0d", "browser", "hq_image_max_edge", "image_edit_zoom", "linked_devices_re_auth_enabled", "media.faly3-2.fna.whatsapp.net", 
+	"media.fdoh5-3.fna.whatsapp.net", "media.fesb3-1.fna.whatsapp.net", "media.fknu1-1.fna.whatsapp.net", "media.fmex3-1.fna.whatsapp.net", "media.fruh4-3.fna.whatsapp.net", 
+	"255", "web_upgrade_to_md_modal", "audio_piggyback_timeout_msec", "enable_audio_oob_fec_feature", "from_ip", "image_max_edge", "message_qr_enabled", "powersave", 
+	"receipt_pre_acking", "video_max_edge", "full", "011", "012", "enable_audio_oob_fec_for_sender", "md_voip_enabled", "enable_privatestats", "max_fec_ratio", 
+	"payments_cs_faq_url", "media-xsp1-3.cdn.whatsapp.net", "hq_image_quality", "media.fasr1-2.fna.whatsapp.net", "media.fbog3-1.fna.whatsapp.net", 
+	"media.ffjr1-6.fna.whatsapp.net", "media.fist2-3.fna.whatsapp.net", "media.flim4-3.fna.whatsapp.net", "media.fpbc2-4.fna.whatsapp.net", "media.fpku1-1.fna.whatsapp.net",
+	"media.frba1-1.fna.whatsapp.net", "media.fudi1-1.fna.whatsapp.net", "media.fvvi1-2.fna.whatsapp.net", "gcm_fg_service", "enable_dec_ltr_size_check", "clear", "lg", 
+	"media.fgru11-1.fna.whatsapp.net", "18", "media-lga3-2.cdn.whatsapp.net", "pkey", "0e", "max_subject", "cond_range_lterm_rtt", "announcement_groups", "biz_profile_options", 
+	"s_t", "media.fabv2-1.fna.whatsapp.net", "media.fcai3-1.fna.whatsapp.net", "media.fcgh1-1.fna.whatsapp.net", "media.fctg1-4.fna.whatsapp.net", "media.fdiy1-1.fna.whatsapp.net",
+	"media.fisb4-1.fna.whatsapp.net", "media.fpku1-2.fna.whatsapp.net", "media.fros9-1.fna.whatsapp.net", "status_v3_text", "usync_sidelist", "17", "announcement", "...", 
+	"md_group_notification", "0f", "animated_pack_in_store", "013", "America/Mexico_City", "1260", "media-ams4-1.cdn.whatsapp.net", "media-cgk1-2.cdn.whatsapp.net", 
+	"media-cpt1-1.cdn.whatsapp.net", "media-maa2-1.cdn.whatsapp.net", "media.fgye10-1.fna.whatsapp.net", "e", "catalog_cart", "hfm_string_changes", "init_bitrate", 
+	"packless_hsm", "group_info", "America/Belem", "50", "960", "cond_range_bwe", "decode", "encode", "media.fada1-8.fna.whatsapp.net", "media.fadb1-2.fna.whatsapp.net", 
+	"media.fasu6-1.fna.whatsapp.net", "media.fbog4-1.fna.whatsapp.net", "media.fcgk9-2.fna.whatsapp.net", "media.fdoh5-2.fna.whatsapp.net", "media.ffjr1-2.fna.whatsapp.net", 
+	"media.fgua1-1.fna.whatsapp.net", "media.fgye1-1.fna.whatsapp.net", "media.fist1-4.fna.whatsapp.net", "media.fpbc2-2.fna.whatsapp.net", "media.fres2-1.fna.whatsapp.net", 
+	"media.fsdq1-2.fna.whatsapp.net", "media.fsub6-5.fna.whatsapp.net", "profilo_enabled", "template_hsm", "use_disorder_prefetching_timer", "video_codec_priority", 
+	"vpx_max_qp", "ptt_reduce_recording_delay", "25", "iphone", "Windows", "s_o", "Africa/Lagos", "abt", "media-kut2-1.cdn.whatsapp.net", "media-mba1-1.cdn.whatsapp.net",
+	"media-mxp1-2.cdn.whatsapp.net", "md_blocklist_v2", "url_text", "enable_short_offset", "group_join_permissions", "enable_audio_piggyback_feature", "image_quality", 
+	"media.fcgk7-2.fna.whatsapp.net", "media.fcgk8-2.fna.whatsapp.net", "media.fclo7-1.fna.whatsapp.net", "media.fcmn1-1.fna.whatsapp.net", "media.feoh1-1.fna.whatsapp.net", 
+	"media.fgyd4-3.fna.whatsapp.net", "media.fjed4-4.fna.whatsapp.net", "media.flim1-4.fna.whatsapp.net", "media.flim2-4.fna.whatsapp.net", "media.fplu6-1.fna.whatsapp.net", 
+	"media.frak1-1.fna.whatsapp.net", "media.fsdq1-1.fna.whatsapp.net", "to_ip", "015", "vp8", "19", "21", "1320", "auth_key_ver", "message_processing_dedup", "server-error",
+	"wap4_enabled", "420", "014", "cond_range_rtt", "ptt_fast_lock_enabled", "media-ort2-1.cdn.whatsapp.net", "fwd_ui_start_ts"
+};
+
+static char *dict3[] = {
+	"contact_blacklist", "Asia/Jakarta", "media.fepa10-1.fna.whatsapp.net", "media.fmex10-3.fna.whatsapp.net", "disorder_prefetching_start_when_empty", "America/Bogota", 
+	"use_local_probing_rx_bitrate", "America/Argentina/Buenos_Aires", "cross_post", "media.fabb1-1.fna.whatsapp.net", "media.fbog4-2.fna.whatsapp.net", "media.fcgk9-1.fna.whatsapp.net", 
+	"media.fcmn2-1.fna.whatsapp.net", "media.fdel3-1.fna.whatsapp.net", "media.ffjr1-1.fna.whatsapp.net", "media.fgdl5-1.fna.whatsapp.net", "media.flpb1-2.fna.whatsapp.net", 
+	"media.fmex2-1.fna.whatsapp.net", "media.frba2-2.fna.whatsapp.net", "media.fros2-2.fna.whatsapp.net", "media.fruh2-1.fna.whatsapp.net", "media.fybz2-2.fna.whatsapp.net", 
+	"options", "20", "a", "017", "018", "mute_always", "user_notice", "Asia/Kolkata", "gif_provider", "locked", "media-gua1-1.cdn.whatsapp.net", "piggyback_exclude_force_flush", 
+	"24", "media.frec39-1.fna.whatsapp.net", "user_remove", "file_max_size", "cond_packet_loss_pct_ema_alpha", "media.facc1-1.fna.whatsapp.net", "media.fadb2-1.fna.whatsapp.net", 
+	"media.faly3-1.fna.whatsapp.net", "media.fbdo6-2.fna.whatsapp.net", "media.fcmn2-2.fna.whatsapp.net", "media.fctg1-3.fna.whatsapp.net", "media.ffez1-2.fna.whatsapp.net", 
+	"media.fist1-3.fna.whatsapp.net", "media.fist2-2.fna.whatsapp.net", "media.flim2-2.fna.whatsapp.net", "media.fmct2-3.fna.whatsapp.net", "media.fpei3-1.fna.whatsapp.net", 
+	"media.frba3-1.fna.whatsapp.net", "media.fsdu8-2.fna.whatsapp.net", "media.fstu2-1.fna.whatsapp.net", "media_type", "receipt_agg", "016", "enable_pli_for_crc_mismatch", 
+	"live", "enc_rekey", "frskmsg", "d", "media.fdel11-2.fna.whatsapp.net", "proto", "2250", "audio_piggyback_enable_cache", "skip_nack_if_ltrp_sent", "mark_dtx_jb_frames", 
+	"web_service_delay", "7282", "catalog_send_all", "outgoing", "360", "30", "LIMITED", "019", "audio_picker", "bpv2_phase", "media.fada1-7.fna.whatsapp.net",
+	"media.faep7-1.fna.whatsapp.net", "media.fbko1-2.fna.whatsapp.net", "media.fbni1-2.fna.whatsapp.net", "media.fbtz1-1.fna.whatsapp.net", "media.fbtz1-8.fna.whatsapp.net", 
+	"media.fcjs3-1.fna.whatsapp.net", "media.fesb3-2.fna.whatsapp.net", "media.fgdl5-4.fna.whatsapp.net", "media.fist2-1.fna.whatsapp.net", "media.flhe2-2.fna.whatsapp.net", 
+	"media.flim2-1.fna.whatsapp.net", "media.fmex1-1.fna.whatsapp.net", "media.fpat3-2.fna.whatsapp.net", "media.fpat3-3.fna.whatsapp.net", "media.fros2-1.fna.whatsapp.net", 
+	"media.fsdu8-1.fna.whatsapp.net", "media.fsub3-2.fna.whatsapp.net", "payments_chat_plugin", "cond_congestion_no_rtcp_thr", "green_alert", "not-a-biz", "..", 
+	"shops_pdp_urls_config", "source", "media-dus1-1.cdn.whatsapp.net", "mute_video", "01b", "currency", "max_keys", "resume_check", "contact_array", "qr_scanning", "23", 
+	"b", "media.fbfh15-1.fna.whatsapp.net", "media.flim22-1.fna.whatsapp.net", "media.fsdu11-1.fna.whatsapp.net", "media.fsdu15-1.fna.whatsapp.net", "Chrome", "fts_version", 
+	"60", "media.fada1-6.fna.whatsapp.net", "media.faep4-2.fna.whatsapp.net", "media.fbaq5-1.fna.whatsapp.net", "media.fbni1-1.fna.whatsapp.net", "media.fcai3-2.fna.whatsapp.net",
+	"media.fdel3-2.fna.whatsapp.net", "media.fdmm3-2.fna.whatsapp.net", "media.fhex3-1.fna.whatsapp.net", "media.fisb4-2.fna.whatsapp.net", "media.fkhi5-2.fna.whatsapp.net", 
+	"media.flos2-1.fna.whatsapp.net", "media.fmct2-1.fna.whatsapp.net", "media.fntr7-1.fna.whatsapp.net", "media.frak3-1.fna.whatsapp.net", "media.fruh5-2.fna.whatsapp.net", 
+	"media.fsub6-1.fna.whatsapp.net", "media.fuab1-2.fna.whatsapp.net", "media.fuio1-1.fna.whatsapp.net", "media.fver1-1.fna.whatsapp.net", "media.fymy1-1.fna.whatsapp.net", 
+	"product_catalog", "1380", "audio_oob_fec_max_pkts", "22", "254", "media-ort2-2.cdn.whatsapp.net", "media-sjc3-1.cdn.whatsapp.net", "1600", "01a", "01c", "405", 
+	"key_frame_interval", "body", "media.fcgh20-1.fna.whatsapp.net", "media.fesb10-2.fna.whatsapp.net", "125", "2000", "media.fbsb1-1.fna.whatsapp.net", 
+	"media.fcmn3-2.fna.whatsapp.net", "media.fcpq1-1.fna.whatsapp.net", "media.fdel1-2.fna.whatsapp.net", "media.ffor2-1.fna.whatsapp.net", "media.fgdl1-4.fna.whatsapp.net", 
+	"media.fhex2-1.fna.whatsapp.net", "media.fist1-2.fna.whatsapp.net", "media.fjed5-2.fna.whatsapp.net", "media.flim6-4.fna.whatsapp.net", "media.flos2-2.fna.whatsapp.net", 
+	"media.fntr6-2.fna.whatsapp.net", "media.fpku3-2.fna.whatsapp.net", "media.fros8-1.fna.whatsapp.net", "media.fymy1-2.fna.whatsapp.net", "ul_bw", "ltrp_qp_offset", 
+	"request", "nack", "dtx_delay_state_reset", "timeoffline", "28", "01f", "32", "enable_ltr_pool", "wa_msys_crypto", "01d", "58", "dtx_freeze_hg_update", 
+	"nack_if_rpsi_throttled", "253", "840", "media.famd15-1.fna.whatsapp.net", "media.fbog17-2.fna.whatsapp.net", "media.fcai19-2.fna.whatsapp.net", "media.fcai21-4.fna.whatsapp.net",
+	"media.fesb10-4.fna.whatsapp.net", "media.fesb10-5.fna.whatsapp.net", "media.fmaa12-1.fna.whatsapp.net", "media.fmex11-3.fna.whatsapp.net", "media.fpoa33-1.fna.whatsapp.net", 
+	"1050", "021", "clean", "cond_range_ema_packet_loss_pct", "media.fadb6-5.fna.whatsapp.net", "media.faqp4-1.fna.whatsapp.net", "media.fbaq3-1.fna.whatsapp.net", 
+	"media.fbel2-1.fna.whatsapp.net", "media.fblr4-2.fna.whatsapp.net", "media.fclo8-1.fna.whatsapp.net", "media.fcoo1-2.fna.whatsapp.net", "media.ffjr1-4.fna.whatsapp.net", 
+	"media.ffor9-1.fna.whatsapp.net", "media.fisb3-1.fna.whatsapp.net", "media.fkhi2-2.fna.whatsapp.net", "media.fkhi4-1.fna.whatsapp.net", "media.fpbc1-2.fna.whatsapp.net", 
+	"media.fruh2-2.fna.whatsapp.net", "media.fruh5-1.fna.whatsapp.net", "media.fsub3-1.fna.whatsapp.net", "payments_transaction_limit", "252", "27", "29", "tintagel", "01e", 
+	"237", "780", "callee_updated_payload", "020", "257", "price", "025", "239", "payments_cs_phone_number", "mediaretry", "w:auth:backup:token", "Glass.caf", "max_bitrate", 
+	"240", "251", "660", "media.fbog16-1.fna.whatsapp.net", "media.fcgh21-1.fna.whatsapp.net", "media.fkul19-2.fna.whatsapp.net", "media.flim21-2.fna.whatsapp.net", 
+	"media.fmex10-4.fna.whatsapp.net", "64", "33", "34", "35", "interruption", "media.fabv3-1.fna.whatsapp.net", "media.fadb6-1.fna.whatsapp.net", "media.fagr1-1.fna.whatsapp.net",
+	"media.famd1-1.fna.whatsapp.net", "media.famm6-1.fna.whatsapp.net", "media.faqp2-3.fna.whatsapp.net"
+};
diff --git a/protocols/WhatsApp/src/iq.cpp b/protocols/WhatsApp/src/iq.cpp
new file mode 100644
index 0000000000..9daff6b6ba
--- /dev/null
+++ b/protocols/WhatsApp/src/iq.cpp
@@ -0,0 +1,709 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+void WhatsAppProto::OnAccountSync(const WANode &node)
+{
+	m_arDevices.destroy();
+
+	for (auto &it : node.getChild("devices")->getChildren())
+		if (it->title == "device")
+			m_arDevices.insert(new WADevice(it->getAttr("jid"), it->getAttrInt("key-index")));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnIqBlockList(const WANode &node)
+{
+	for (auto &it : node.getChild("list")->getChildren()) {
+		auto *pUser = AddUser(it->getAttr("jid"), false);
+		Contact::Hide(pUser->hContact);
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnIqCountPrekeys(const WANode &node)
+{
+	int iCount = node.getChild("count")->getAttrInt("value");
+	if (iCount < 5)
+		UploadMorePrekeys();
+}
+
+void WhatsAppProto::UploadMorePrekeys()
+{
+	WANodeIq iq(IQ::SET, "encrypt");
+
+	auto regId = encodeBigEndian(getDword(DBKEY_REG_ID));
+	iq.addChild("registration")->content.append(regId.c_str(), regId.size());
+
+	iq.addChild("type")->content.append(KEY_BUNDLE_TYPE, 1);
+	iq.addChild("identity")->content.append(m_signalStore.signedIdentity.pub);
+
+	const int PORTION = 10;
+	m_signalStore.generatePrekeys(PORTION);
+
+	int iStart = getDword(DBKEY_PREKEY_UPLOAD_ID, 1);
+	auto *n = iq.addChild("list");
+	for (int i = 0; i < PORTION; i++) {
+		auto *nKey = n->addChild("key");
+
+		int keyId = iStart + i;
+		auto encId = encodeBigEndian(keyId, 3);
+		nKey->addChild("id")->content.append(encId.c_str(), encId.size());
+		nKey->addChild("value")->content.append(getBlob(CMStringA(FORMAT, "PreKey%dPublic", keyId)));
+	}
+	setDword(DBKEY_PREKEY_UPLOAD_ID, iStart + PORTION);
+
+	auto *skey = iq.addChild("skey");
+
+	auto encId = encodeBigEndian(m_signalStore.preKey.keyid, 3);
+	skey->addChild("id")->content.append(encId.c_str(), encId.size());
+	skey->addChild("value")->content.append(m_signalStore.preKey.pub);
+	skey->addChild("signature")->content.append(m_signalStore.preKey.signature);
+
+	WSSendNode(iq, &WhatsAppProto::OnIqDoNothing);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnIqDoNothing(const WANode &)
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnNotifyEncrypt(const WANode &node)
+{
+	auto *pszFrom = node.getAttr("from");
+	if (!mir_strcmp(pszFrom, S_WHATSAPP_NET)) {
+
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnReceiveInfo(const WANode &node)
+{
+	if (auto *pChild = node.getFirstChild()) {
+		if (pChild->title == "offline")
+			debugLogA("Processed %d offline events", pChild->getAttrInt("count"));
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnReceiveMessage(const WANode &node)
+{
+	auto *msgId = node.getAttr("id");
+	auto *msgType = node.getAttr("type");
+	auto *msgFrom = node.getAttr("from");
+	auto *category = node.getAttr("category");
+	auto *recipient = node.getAttr("recipient");
+	auto *participant = node.getAttr("participant");
+
+	if (msgType == nullptr || msgFrom == nullptr || msgId == nullptr) {
+		debugLogA("bad message received: <%s> <%s> <%s>", msgType, msgFrom, msgId);
+		return;
+	}
+
+	WAMSG type;
+	WAJid jid(msgFrom);
+	CMStringA szAuthor, szChatId;
+
+	if (node.getAttr("offline"))
+		type.bOffline = true;
+
+	// message from one user to another
+	if (jid.isUser()) {
+		if (recipient) {
+			if (m_szJid != msgFrom) {
+				debugLogA("strange message: with recipient, but not from me");
+				return;
+			}
+			szChatId = recipient;
+		}
+		else szChatId = msgFrom;
+
+		type.bPrivateChat = true;
+		szAuthor = msgFrom;
+	}
+	else if (jid.isGroup()) {
+		if (!participant) {
+			debugLogA("strange message: from group, but without participant");
+			return;
+		}
+
+		type.bGroupChat = true;
+		szAuthor = participant;
+		szChatId = msgFrom;
+	}
+	else if (jid.isBroadcast()) {
+		if (!participant) {
+			debugLogA("strange message: from group, but without participant");
+			return;
+		}
+
+		bool bIsMe = m_szJid == participant;
+		if (jid.isStatusBroadcast()) {
+			if (bIsMe)
+				type.bDirectStatus = true;
+			else
+				type.bOtherStatus = true;
+		}
+		else {
+			if (bIsMe)
+				type.bPeerBroadcast = true;
+			else 
+				type.bOtherBroadcast = true;
+		}
+		szChatId = msgFrom;
+		szAuthor = participant;
+	}
+	else {
+		debugLogA("invalid message type");
+		return;
+	}
+
+	CMStringA szSender = (type.bPrivateChat) ? szAuthor : szChatId;
+	bool bFromMe = (m_szJid == msgFrom);
+	if (!bFromMe && participant)
+		bFromMe = m_szJid == participant;
+
+	auto *pKey = new proto::MessageKey();
+	pKey->set_remotejid(szChatId);
+	pKey->set_id(msgId);
+	pKey->set_fromme(bFromMe);
+	if (participant)
+		pKey->set_participant(participant);
+
+	proto::WebMessageInfo msg;
+	msg.set_allocated_key(pKey);
+	msg.set_messagetimestamp(_atoi64(node.getAttr("t")));
+	msg.set_pushname(node.getAttr("notify"));
+	if (bFromMe)
+		msg.set_status(proto::WebMessageInfo_Status_SERVER_ACK);
+
+	int iDecryptable = 0;
+
+	for (auto &it: node.getChildren()) {
+		if (it->title == "verified_name") {
+			proto::VerifiedNameCertificate cert;
+			cert << it->content;
+			
+			proto::VerifiedNameCertificate::Details details;
+			details.ParseFromString(cert.details());
+
+			msg.set_verifiedbizname(details.verifiedname());
+			continue;
+		}
+		
+		if (it->title != "enc" || it->content.length() == 0)
+			continue;
+
+		SignalBuffer msgBody;
+		auto *pszType = it->getAttr("type");
+		try {
+			if (!mir_strcmp(pszType, "pkmsg") || !mir_strcmp(pszType, "msg")) {
+				CMStringA szUser = (WAJid(szSender).isUser()) ? szSender : szAuthor;
+				msgBody = m_signalStore.decryptSignalProto(szUser, pszType, it->content);
+			}
+			else if (!mir_strcmp(pszType, "skmsg")) {
+				msgBody = m_signalStore.decryptGroupSignalProto(szSender, szAuthor, it->content);
+			}
+			else throw "Invalid e2e type";
+
+			if (!msgBody)
+				throw "Invalid e2e message";
+
+			iDecryptable++;
+
+			// remove message padding
+			if (size_t len = msgBody.len()) {
+				size_t c = msgBody.data()[len - 1];
+				if (c < len)
+					msgBody.reset(len - c);
+			}
+
+			proto::Message encMsg;
+			encMsg.ParseFromArray(msgBody.data(), msgBody.len());
+			if (encMsg.devicesentmessage().has_message())
+				msg.set_allocated_message(new proto::Message(encMsg.devicesentmessage().message()));
+			else
+				msg.set_allocated_message(new proto::Message(encMsg));
+
+			if (encMsg.has_senderkeydistributionmessage())
+				m_signalStore.processSenderKeyMessage(encMsg.senderkeydistributionmessage());
+
+			ProcessMessage(type, msg);
+			msg.clear_message();
+
+			// send receipt
+			const char *pszReceiptType = nullptr, *pszReceiptTo = participant;
+			if (!mir_strcmp(category, "peer"))
+				pszReceiptType = "peer_msg";
+			else if (bFromMe) {
+				// message was sent by me from a different device
+				pszReceiptType = "sender";
+				if (WAJid(szChatId).isUser())
+					pszReceiptTo = szAuthor;
+			}
+			else if (!m_hServerConn)
+				pszReceiptType = "inactive";
+
+			SendReceipt(szChatId, pszReceiptTo, msgId, pszReceiptType);
+		}
+		catch (const char *pszError) {
+			debugLogA("Message cannot be parsed: %s", pszError);
+		}
+
+		if (!iDecryptable) {
+			debugLogA("Nothing to decrypt");
+			return;
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnStreamError(const WANode &node)
+{
+	m_bTerminated = true;
+
+	if (auto *pszCode = node.getAttr("code")) {
+		switch (atoi(pszCode)) {
+		case 401:
+			debugLogA("Connection logged out from another device, exiting");
+			break;
+
+		case 408:
+			debugLogA("Connection lost, exiting");
+			break;
+
+		case 411:
+			debugLogA("Conflict between two devices, exiting");
+			break;
+
+		case 428:
+			debugLogA("Connection forcibly closed by the server, exiting");
+			break;
+
+		case 440:
+			debugLogA("Connection replaced from another device, exiting");
+			break;
+
+		case 515:
+			debugLogA("Server required to restart immediately, leaving thread");
+			m_bRespawn = true;
+			break;
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnIqResult(const WANode &node)
+{
+	if (auto *pszId = node.getAttr("id"))
+		for (auto &it: m_arPacketQueue) 
+			if (it->szPacketId == pszId)
+				(this->*it->pHandler)(node);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnIqPairDevice(const WANode &node)
+{
+	WSSendNode(WANodeIq(IQ::RESULT) << CHAR_PARAM("id", node.getAttr("id")));
+
+	if (auto *pRef = node.getChild("pair-device")->getChild("ref")) {
+		ShowQrCode(pRef->getBody());
+	}
+	else {
+		debugLogA("OnIqPairDevice: got reply without ref, exiting");
+		ShutdownSession();
+	}
+}
+
+void WhatsAppProto::OnIqPairSuccess(const WANode &node)
+{
+	CloseQrDialog();
+
+	auto *pRoot = node.getChild("pair-success");
+
+	try {
+		if (auto *pPlatform = pRoot->getChild("platform"))
+			debugLogA("Got response from platform: %s", pPlatform->getBody().c_str());
+
+		if (auto *pBiz = pRoot->getChild("biz"))
+			if (auto *pszName = pBiz->getAttr("name"))
+				setUString("Nick", pszName);
+
+		if (auto *pDevice = pRoot->getChild("device")) {
+			if (auto *pszJid = pDevice->getAttr("jid")) {
+				WAJid jid(pszJid);
+				m_szJid = jid.user + "@" + jid.server;
+				setUString(DBKEY_JID, m_szJid);
+				setDword(DBKEY_DEVICE_ID, jid.device);
+			}
+		}
+		else throw "OnIqPairSuccess: got reply without device info, exiting";
+
+		if (auto *pIdentity = pRoot->getChild("device-identity")) {
+			proto::ADVSignedDeviceIdentityHMAC payload;
+			if (!payload.ParseFromArray(pIdentity->content.data(), (int)pIdentity->content.length()))
+				throw "OnIqPairSuccess: got reply with invalid identity, exiting";
+
+			auto &hmac = payload.hmac();
+			auto &details = payload.details();
+			{
+				// check details signature using HMAC
+				uint8_t signature[32];
+				unsigned int out_len = sizeof(signature);
+				MBinBuffer secret(getBlob(DBKEY_SECRET_KEY));
+				HMAC(EVP_sha256(), secret.data(), (int)secret.length(), (BYTE *)details.c_str(), (int)details.size(), signature, &out_len);
+				if (memcmp(hmac.c_str(), signature, sizeof(signature)))
+					throw "OnIqPairSuccess: got reply with invalid details signature, exiting";
+			}
+
+			proto::ADVSignedDeviceIdentity account;
+			if (!account.ParseFromString(details))
+				throw "OnIqPairSuccess: got reply with invalid account, exiting";
+
+			auto &deviceDetails = account.details();
+			auto &accountSignature = account.accountsignature();
+			auto &accountSignatureKey = account.accountsignaturekey();
+			{
+				MBinBuffer buf;
+				buf.append("\x06\x00", 2);
+				buf.append(deviceDetails.c_str(), deviceDetails.size());
+				buf.append(m_signalStore.signedIdentity.pub);
+
+				ec_public_key key = {};
+				memcpy(key.data, accountSignatureKey.c_str(), sizeof(key.data));
+				if (1 != curve_verify_signature(&key, (BYTE *)buf.data(), buf.length(), (BYTE *)accountSignature.c_str(), accountSignature.size()))
+					throw "OnIqPairSuccess: got reply with invalid account signature, exiting";
+			}
+			debugLogA("Received valid account signature");
+			{
+				MBinBuffer buf;
+				buf.append("\x06\x01", 2);
+				buf.append(deviceDetails.c_str(), deviceDetails.size());
+				buf.append(m_signalStore.signedIdentity.pub);
+				buf.append(accountSignatureKey.c_str(), accountSignatureKey.size());
+
+				signal_buffer *result;
+				ec_private_key key = {};
+				memcpy(key.data, m_signalStore.signedIdentity.priv.data(), m_signalStore.signedIdentity.priv.length());
+				if (curve_calculate_signature(m_signalStore.CTX(), &result, &key, (BYTE *)buf.data(), buf.length()) != 0)
+					throw "OnIqPairSuccess: cannot calculate account signature, exiting";
+
+				account.set_devicesignature(result->data, result->len);
+				signal_buffer_free(result);
+			}
+
+			setDword("SignalDeviceId", 0);
+			{
+				MBinBuffer key;
+				if (accountSignatureKey.size() == 32)
+					key.append(KEY_BUNDLE_TYPE, 1);
+				key.append(accountSignatureKey.c_str(), accountSignatureKey.size());
+				db_set_blob(0, m_szModuleName, "SignalIdentifierKey", key.data(), (int)key.length());
+			}
+
+			account.clear_accountsignaturekey();
+
+			MBinBuffer accountEnc(account.ByteSize());
+			account.SerializeToArray(accountEnc.data(), (int)accountEnc.length());
+			db_set_blob(0, m_szModuleName, "WAAccount", accountEnc.data(), (int)accountEnc.length());
+
+			proto::ADVDeviceIdentity deviceIdentity;
+			deviceIdentity.ParseFromString(deviceDetails);
+
+			WANodeIq reply(IQ::RESULT); reply << CHAR_PARAM("id", node.getAttr("id"));
+
+			WANode *nodePair = reply.addChild("pair-device-sign");
+
+			WANode *nodeDeviceIdentity = nodePair->addChild("device-identity");
+			nodeDeviceIdentity->addAttr("key-index", deviceIdentity.keyindex());
+			nodeDeviceIdentity->content.append(accountEnc.data(), accountEnc.length());
+			WSSendNode(reply);
+		}
+		else throw "OnIqPairSuccess: got reply without identity, exiting";
+	}
+	catch (const char *pErrMsg) {
+		debugLogA(pErrMsg);
+		ShutdownSession();
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnProcessHandshake(const void *pData, int cbLen)
+{
+	proto::HandshakeMessage msg;
+	if (!msg.ParseFromArray(pData, cbLen)) {
+		debugLogA("Error parsing data, exiting");
+
+LBL_Error:
+		ShutdownSession();
+		return;
+	}
+
+	auto &static_ = msg.serverhello().static_();
+	auto &payload_ = msg.serverhello().payload();
+	auto &ephemeral_ = msg.serverhello().ephemeral();
+
+	m_noise->updateHash(ephemeral_.c_str(), ephemeral_.size());
+	m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), ephemeral_.c_str());
+
+	MBinBuffer decryptedStatic = m_noise->decrypt(static_.c_str(), static_.size());
+	m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), decryptedStatic.data());
+
+	MBinBuffer decryptedCert = m_noise->decrypt(payload_.c_str(), payload_.size());
+
+	proto::CertChain cert; cert.ParseFromArray(decryptedCert.data(), (int)decryptedCert.length());
+	proto::CertChain::NoiseCertificate::Details details; details.ParseFromString(cert.intermediate().details());
+	if (details.issuerserial() != 0) {
+		debugLogA("Invalid certificate serial number, exiting");
+		goto LBL_Error;
+	}
+
+	MBinBuffer encryptedPub = m_noise->encrypt(m_noise->noiseKeys.pub.data(), m_noise->noiseKeys.pub.length());
+	m_noise->mixIntoKey(m_noise->noiseKeys.priv.data(), ephemeral_.c_str());
+
+	// create reply
+	proto::ClientPayload node;
+
+	MFileVersion v;
+	Miranda_GetFileVersion(&v);
+
+	// not received our jid from server? generate registration packet then
+	if (m_szJid.IsEmpty()) {
+		uint8_t appVersion[16];
+		mir_md5_hash((BYTE *)APP_VERSION, sizeof(APP_VERSION) - 1, appVersion);
+
+		auto *pAppVersion = new proto::DeviceProps_AppVersion();
+		pAppVersion->set_primary(v[0]);
+		pAppVersion->set_secondary(v[1]);
+		pAppVersion->set_tertiary(v[2]);
+		pAppVersion->set_quaternary(v[3]);
+
+		proto::DeviceProps pCompanion;
+		pCompanion.set_os("Miranda");
+		pCompanion.set_allocated_version(pAppVersion);
+		pCompanion.set_platformtype(proto::DeviceProps_PlatformType_DESKTOP);
+		pCompanion.set_requirefullsync(false);
+
+		MBinBuffer buf(pCompanion.ByteSize());
+		pCompanion.SerializeToArray(buf.data(), (int)buf.length());
+
+		auto *pPairingData = new proto::ClientPayload_DevicePairingRegistrationData();
+		pPairingData->set_deviceprops(buf.data(), buf.length());
+		pPairingData->set_buildhash(appVersion, sizeof(appVersion));
+		pPairingData->set_eregid(encodeBigEndian(getDword(DBKEY_REG_ID)));
+		pPairingData->set_ekeytype(KEY_BUNDLE_TYPE);
+		pPairingData->set_eident(m_signalStore.signedIdentity.pub.data(), m_signalStore.signedIdentity.pub.length());
+		pPairingData->set_eskeyid(encodeBigEndian(m_signalStore.preKey.keyid));
+		pPairingData->set_eskeyval(m_signalStore.preKey.pub.data(), m_signalStore.preKey.pub.length());
+		pPairingData->set_eskeysig(m_signalStore.preKey.signature.data(), m_signalStore.preKey.signature.length());
+		node.set_allocated_devicepairingdata(pPairingData);
+
+		node.set_passive(false);
+	}
+	// generate login packet
+	else {
+		WAJid jid(m_szJid);
+		node.set_username(_atoi64(jid.user));
+		node.set_device(getDword(DBKEY_DEVICE_ID));
+		node.set_passive(true);
+	}
+
+	auto *pUserVersion = new proto::ClientPayload_UserAgent_AppVersion();
+	pUserVersion->set_primary(2);
+	pUserVersion->set_secondary(2230);
+	pUserVersion->set_tertiary(15);
+
+	auto *pUserAgent = new proto::ClientPayload_UserAgent();
+	pUserAgent->set_allocated_appversion(pUserVersion);
+	pUserAgent->set_platform(proto::ClientPayload_UserAgent_Platform_WEB);
+	pUserAgent->set_releasechannel(proto::ClientPayload_UserAgent_ReleaseChannel_RELEASE);
+	pUserAgent->set_mcc("000");
+	pUserAgent->set_mnc("000");
+	pUserAgent->set_osversion("0.1");
+	pUserAgent->set_osbuildnumber("0.1");
+	pUserAgent->set_manufacturer("");
+	pUserAgent->set_device("Desktop");
+	pUserAgent->set_localelanguageiso6391("en");
+	pUserAgent->set_localecountryiso31661alpha2("US");
+
+	auto *pWebInfo = new proto::ClientPayload_WebInfo();
+	pWebInfo->set_websubplatform(proto::ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER);
+
+	node.set_connecttype(proto::ClientPayload_ConnectType_WIFI_UNKNOWN);
+	node.set_connectreason(proto::ClientPayload_ConnectReason_USER_ACTIVATED);
+	node.set_allocated_useragent(pUserAgent);
+	node.set_allocated_webinfo(pWebInfo);
+
+	MBinBuffer payload(node.ByteSize());
+	node.SerializeToArray(payload.data(), (int)payload.length());
+
+	MBinBuffer payloadEnc = m_noise->encrypt(payload.data(), payload.length());
+
+	auto *pFinish = new proto::HandshakeMessage_ClientFinish();
+	pFinish->set_payload(payloadEnc.data(), payloadEnc.length());
+	pFinish->set_static_(encryptedPub.data(), encryptedPub.length());
+
+	proto::HandshakeMessage handshake;
+	handshake.set_allocated_clientfinish(pFinish);
+	WSSend(handshake);
+
+	m_noise->finish();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnServerSync(const WANode &node)
+{
+	OBJLIST<WACollection> task(1);
+
+	for (auto &it : node.getChildren())
+		if (it->title == "collection")
+			task.insert(new WACollection(it->getAttr("name"), it->getAttrInt("version")));
+
+	ResyncServer(task);
+}
+
+void WhatsAppProto::ResyncServer(const OBJLIST<WACollection> &task)
+{
+	WANodeIq iq(IQ::SET, "w:sync:app:state");
+	
+	auto *pList = iq.addChild("sync");
+	for (auto &it : task) {
+		auto *pCollection = m_arCollections.find(it);
+		if (pCollection == nullptr)
+			m_arCollections.insert(pCollection = new WACollection(it->szName, 0));
+
+		if (pCollection->version < it->version) {
+			auto *pNode = pList->addChild("collection");
+			*pNode << CHAR_PARAM("name", it->szName) << INT_PARAM("version", pCollection->version) 
+				<< CHAR_PARAM("return_snapshot", (!pCollection->version) ? "true" : "false");
+		}
+	}
+
+	if (pList->getFirstChild() != nullptr)
+		WSSendNode(iq, &WhatsAppProto::OnIqServerSync);
+}
+
+void WhatsAppProto::OnIqServerSync(const WANode &node)
+{
+	for (auto &coll : node.getChild("sync")->getChildren()) {
+		if (coll->title != "collection")
+			continue;
+
+		auto *pszName = coll->getAttr("name");
+		
+		auto *pCollection = FindCollection(pszName);
+		if (pCollection == nullptr) {
+			pCollection = new WACollection(pszName, 0);
+			m_arCollections.insert(pCollection);
+		}
+
+		int dwVersion = 0;
+
+		CMStringW wszSnapshotPath(GetTmpFileName("collection", pszName));
+		if (auto *pSnapshot = coll->getChild("snapshot")) {
+			proto::ExternalBlobReference body;
+			body << pSnapshot->content;
+			if (!body.has_directpath() || !body.has_mediakey()) {
+				debugLogA("Invalid snapshot data, skipping");
+				continue;
+			}
+			
+			MBinBuffer buf = DownloadEncryptedFile(directPath2url(body.directpath().c_str()), body.mediakey(), "App State");
+			if (!buf.data()) {
+				debugLogA("Invalid downloaded snapshot data, skipping");
+				continue;
+			}
+
+			proto::SyncdSnapshot snapshot;
+			snapshot << buf;
+
+			dwVersion = snapshot.version().version();
+			if (dwVersion > pCollection->version) {
+				auto &hash = snapshot.mac();
+				pCollection->hash.assign(hash.c_str(), hash.size());
+				
+				for (auto &it : snapshot.records())
+					pCollection->parseRecord(it, true);
+			}
+		}
+
+		if (auto *pPatchList = coll->getChild("patches")) {
+			for (auto &it : pPatchList->getChildren()) {
+				proto::SyncdPatch patch;
+				patch << it->content;
+
+				dwVersion = patch.version().version();
+				if (dwVersion > pCollection->version)
+					for (auto &jt : patch.mutations())
+						pCollection->parseRecord(jt.record(), jt.operation() == proto::SyncdMutation_SyncdOperation::SyncdMutation_SyncdOperation_SET);
+			}
+		}
+
+		CMStringA szSetting(FORMAT, "Collection_%s", pszName);
+		// setDword(szSetting, dwVersion);
+
+		JSONNode jsonRoot, jsonMap; 
+		for (auto &it : pCollection->indexValueMap)
+			jsonMap << CHAR_PARAM(ptrA(mir_base64_encode(it.first.c_str(), it.first.size())), ptrA(mir_base64_encode(it.second.c_str(), it.second.size())));
+		jsonRoot << INT_PARAM("version", dwVersion) << JSON_PARAM("indexValueMap", jsonMap);
+		
+		// string2file(jsonRoot.write(), GetTmpFileName("collection", CMStringA(pszName) + ".json"));
+	}
+}
+
+void WACollection::parseRecord(const ::proto::SyncdRecord &rec, bool bSet)
+{
+	// auto &id = rec.keyid().id();
+	auto &index = rec.index().blob();
+	auto &value = rec.value().blob();
+
+	if (bSet) {
+		indexValueMap[index] = value.substr(0, value.size() - 32);
+	}
+	else indexValueMap.erase(index);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnSuccess(const WANode &)
+{
+	OnLoggedIn();
+
+	WSSendNode(WANodeIq(IQ::SET, "passive") << XCHILD("active"), &WhatsAppProto::OnIqDoNothing);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::InitPersistentHandlers()
+{
+	m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-device", &WhatsAppProto::OnIqPairDevice));
+	m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-success", &WhatsAppProto::OnIqPairSuccess));
+
+	m_arPersistent.insert(new WAPersistentHandler("notification", "encrypt", 0, 0, &WhatsAppProto::OnNotifyEncrypt));
+	m_arPersistent.insert(new WAPersistentHandler("notification", "account_sync", 0, 0, &WhatsAppProto::OnAccountSync));
+	m_arPersistent.insert(new WAPersistentHandler("notification", "server_sync", 0, 0, &WhatsAppProto::OnServerSync));
+
+	m_arPersistent.insert(new WAPersistentHandler("ib", 0, 0, 0, &WhatsAppProto::OnReceiveInfo));
+	m_arPersistent.insert(new WAPersistentHandler("message", 0, 0, 0, &WhatsAppProto::OnReceiveMessage));
+	m_arPersistent.insert(new WAPersistentHandler("stream:error", 0, 0, 0, &WhatsAppProto::OnStreamError));
+	m_arPersistent.insert(new WAPersistentHandler("success", 0, 0, 0, &WhatsAppProto::OnSuccess));
+
+	m_arPersistent.insert(new WAPersistentHandler(0, "result", 0, 0, &WhatsAppProto::OnIqResult));
+}
diff --git a/protocols/WhatsApp/src/main.cpp b/protocols/WhatsApp/src/main.cpp
new file mode 100644
index 0000000000..e166fc73c3
--- /dev/null
+++ b/protocols/WhatsApp/src/main.cpp
@@ -0,0 +1,69 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+#include "version.h"
+
+#ifdef _DEBUG
+#pragma comment(lib, "libprotobufd.lib")
+#else
+#pragma comment(lib, "libprotobuf.lib")
+#endif
+
+CMPlugin g_plugin;
+
+PLUGININFOEX pluginInfo = {
+	sizeof(PLUGININFOEX),
+	__PLUGIN_NAME,
+	PLUGIN_MAKE_VERSION(__MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM),
+	__DESCRIPTION,
+	__AUTHOR,
+	__AUTHOREMAIL,
+	__COPYRIGHT,
+	UNICODE_AWARE, //not transient
+	// {008B9CE1-154B-44E4-9823-97C1AAB00C3C}
+	{ 0x8b9ce1, 0x154b, 0x44e4, { 0x98, 0x23, 0x97, 0xc1, 0xaa, 0xb0, 0xc, 0x3c }}
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Interface information
+
+extern "C" __declspec(dllexport) const MUUID MirandaInterfaces[] = { MIID_PROTOCOL, MIID_LAST };
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+CMPlugin::CMPlugin() :
+	ACCPROTOPLUGIN<WhatsAppProto>(MODULENAME, pluginInfo)
+{
+	SetUniqueId(DBKEY_JID);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Load
+
+int CMPlugin::Load()
+{
+	// InitIcons();
+	// InitContactMenus();
+
+	NETLIBUSER nlu = {};
+	nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE;
+	nlu.szSettingsModule = "WhatsApp";
+	nlu.szDescriptiveName.w = TranslateT("WhatsApp (HTTP)");
+	hAvatarUser = Netlib_RegisterUser(&nlu);
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Unload
+
+int CMPlugin::Unload()
+{
+	Netlib_CloseHandle(hAvatarConn);
+	Netlib_CloseHandle(hAvatarUser);
+	return 0;
+}
diff --git a/protocols/WhatsApp/src/message.cpp b/protocols/WhatsApp/src/message.cpp
new file mode 100644
index 0000000000..e3440a7207
--- /dev/null
+++ b/protocols/WhatsApp/src/message.cpp
@@ -0,0 +1,130 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+static const proto::Message& getBody(const proto::Message &message)
+{
+	if (message.has_ephemeralmessage()) {
+		auto &pMsg = message.ephemeralmessage().message();
+		return (pMsg.has_viewoncemessage()) ? pMsg.viewoncemessage().message() : pMsg;
+	}
+
+	if (message.has_viewoncemessage())
+		return message.viewoncemessage().message();
+
+	return message;
+}
+
+void WhatsAppProto::ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg)
+{
+	auto &key = msg.key();
+	auto &body = getBody(msg.message());
+	bool bFromMe = key.fromme();
+
+	debugLogA("Got a message: %s", msg.Utf8DebugString().c_str());
+
+	uint32_t timestamp = msg.messagetimestamp();
+	auto &participant = key.participant();
+	auto &chatId = key.remotejid();
+	auto &msgId = key.id();
+	
+	WAUser *pUser = FindUser(chatId.c_str());
+	if (pUser == nullptr) {
+		if (type.bPrivateChat)
+			pUser = AddUser(chatId.c_str(), false, false);
+		else if (type.bGroupChat)
+			pUser = AddUser(chatId.c_str(), false, true);
+	}
+
+	if (!bFromMe && msg.has_pushname() && pUser && !pUser->bIsGroupChat)
+		setUString(pUser->hContact, "Nick", msg.pushname().c_str());
+
+	// try to extract some text 
+	if (body.has_conversation()) {
+		auto &conversation = body.conversation();
+		if (!conversation.empty()) {
+			PROTORECVEVENT pre = {};
+			pre.timestamp = timestamp;
+			pre.szMessage = (char*)conversation.c_str();
+			pre.szMsgId = msgId.c_str();
+			if (type.bOffline)
+				pre.flags |= PREF_CREATEREAD;
+			if (bFromMe)
+				pre.flags |= PREF_SENT;
+			ProtoChainRecvMsg(pUser->hContact, &pre);
+		}
+	}
+
+	if (body.has_protocolmessage()) {
+		auto &protoMsg = body.protocolmessage();
+		switch (protoMsg.type()) {
+		case proto::Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE:
+			if (protoMsg.appstatesynckeyshare().keys_size()) {
+				for (auto &it : protoMsg.appstatesynckeyshare().keys()) {
+					auto &keyid = it.keyid().keyid();
+					auto &keydata = it.keydata().keydata();
+
+					CMStringA szSetting(FORMAT, "AppSyncKey%d", decodeBigEndian(keyid));
+					db_set_blob(0, m_szModuleName, szSetting, keydata.c_str(), (unsigned)keydata.size());
+				}
+			}
+			break;
+
+		case proto::Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION:
+			debugLogA("History sync notification");
+			break;
+
+		case proto::Message_ProtocolMessage_Type_REVOKE:
+			break;
+
+		case proto::Message_ProtocolMessage_Type_EPHEMERAL_SETTING:
+			if (pUser) {
+				setDword(pUser->hContact, DBKEY_EPHEMERAL_TS, timestamp);
+				setDword(pUser->hContact, DBKEY_EPHEMERAL_EXPIRE, protoMsg.ephemeralexpiration());
+			}
+			break;
+		}
+	}
+	else if (body.has_reactionmessage()) {
+		debugLogA("Got a reaction to a message");
+	}
+	else if (msg.has_messagestubtype()) {
+		switch (msg.messagestubtype()) {
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_LEAVE:
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_REMOVE:
+			debugLogA("Participant %s removed from chat", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD:
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_INVITE:
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN:
+			debugLogA("Participant %s added to chat", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_DEMOTE:
+			debugLogA("Participant %s demoted", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_PARTICIPANT_PROMOTE:
+			debugLogA("Participant %s promoted", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_CHANGE_ANNOUNCE:
+			debugLogA("Groupchat announce", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_CHANGE_RESTRICT:
+			debugLogA("Groupchat restriction", participant.c_str());
+			break;
+
+		case proto::WebMessageInfo::GROUP_CHANGE_SUBJECT:
+			debugLogA("Groupchat subject was changed", participant.c_str());
+			break;
+		}
+	}
+}
diff --git a/protocols/WhatsApp/src/noise.cpp b/protocols/WhatsApp/src/noise.cpp
new file mode 100644
index 0000000000..db08716050
--- /dev/null
+++ b/protocols/WhatsApp/src/noise.cpp
@@ -0,0 +1,203 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+WANoise class implementation
+
+*/
+
+#include "stdafx.h"
+
+static uint8_t intro_header[] = {87, 65, 6, DICT_VERSION};
+static uint8_t noise_init[] = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+
+WANoise::WANoise(WhatsAppProto *_ppro) :
+	ppro(_ppro)
+{
+	salt.assign(noise_init, 32);
+	encKey.assign(noise_init, 32);
+	decKey.assign(noise_init, 32);
+
+	// generate ephemeral keys: public & private
+	ec_key_pair *pKeys;
+	curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys);
+
+	auto *pPubKey = ec_key_pair_get_public(pKeys);
+	ephemeral.pub.assign(pPubKey->data, sizeof(pPubKey->data));
+
+	auto *pPrivKey = ec_key_pair_get_private(pKeys);
+	ephemeral.priv.assign(pPrivKey->data, sizeof(pPrivKey->data));
+	ec_key_pair_destroy((signal_type_base*)pKeys);
+
+	// prepare hash
+	memcpy(hash, noise_init, 32);
+	updateHash(intro_header, 4);
+	updateHash(ephemeral.pub.data(), ephemeral.pub.length());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// libsignal data initialization
+
+void WANoise::init()
+{
+	// no data? generate them
+	if (ppro->getDword(DBKEY_REG_ID, 0xFFFF) == 0xFFFF) {
+		// generate registration id
+		uint32_t regId;
+		Utils_GetRandom(&regId, sizeof(regId));
+		ppro->setDword(DBKEY_REG_ID, regId & 0x3FFF);
+
+		// generate secret key
+		uint8_t secretKey[32];
+		Utils_GetRandom(secretKey, sizeof(secretKey));
+		db_set_blob(0, ppro->m_szModuleName, DBKEY_SECRET_KEY, secretKey, sizeof(secretKey));
+
+		// generate noise keys (private & public)
+		ec_key_pair *pKeys;
+		curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys);
+
+		auto *pPubKey = ec_key_pair_get_public(pKeys);
+		db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PUB, pPubKey->data, sizeof(pPubKey->data));
+
+		auto *pPrivKey = ec_key_pair_get_private(pKeys);
+		db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PRIV, pPrivKey->data, sizeof(pPrivKey->data));
+		ec_key_pair_destroy((signal_type_base *)pKeys);
+	}
+
+	noiseKeys.pub = ppro->getBlob(DBKEY_NOISE_PUB);
+	noiseKeys.priv = ppro->getBlob(DBKEY_NOISE_PRIV);
+}
+
+void WANoise::finish()
+{
+	deriveKey("", 0, encKey, decKey);
+	readCounter = writeCounter = 0;
+	memset(hash, 0, sizeof(hash));
+	bInitFinished = true;
+}
+
+void WANoise::deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read)
+{
+	size_t outlen = 64;
+	uint8_t out[64];
+	HKDF(EVP_sha256(), (BYTE *)salt.data(), (int)salt.length(), (BYTE *)pData, (int)cbLen, (BYTE *)"", 0, out, outlen);
+
+	write.assign(out, 32);
+	read.assign(out + 32, 32);
+}
+
+void WANoise::mixIntoKey(const void *n, const void *p)
+{
+	uint8_t tmp[32];
+	curve25519_donna((unsigned char *)tmp, (const unsigned char *)n, (const unsigned char *)p);
+
+	deriveKey(tmp, sizeof(tmp), salt, encKey);
+	decKey.assign(encKey.data(), encKey.length());
+	readCounter = writeCounter = 0;
+}
+
+MBinBuffer WANoise::decrypt(const void *pData, size_t cbLen)
+{
+	uint8_t iv[12];
+	generateIV(iv, (bInitFinished) ? readCounter : writeCounter);
+
+	MBinBuffer res;
+	if (!bInitFinished)
+		res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen, hash, sizeof(hash));
+	else
+		res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen);
+
+	updateHash(pData, cbLen);
+	return res;
+}
+
+size_t WANoise::decodeFrame(const void *&pData, size_t &cbLen)
+{
+	auto *p = (const uint8_t *)pData;
+
+	if (cbLen < 3)
+		return 0;
+
+	size_t payloadLen = 0;
+	for (int i = 0; i < 3; i++) {
+		payloadLen <<= 8;
+		payloadLen += p[i];
+	}
+
+	// ppro->debugLogA("got payload of size %d", payloadLen);
+
+	cbLen -= 3;
+	if (payloadLen > cbLen) {
+		ppro->debugLogA("payload length %d exceeds capacity %d", payloadLen, cbLen);
+		return 0;
+	}
+
+	pData = p + 3;
+	return payloadLen;
+}
+
+MBinBuffer WANoise::encodeFrame(const void *pData, size_t cbLen)
+{
+	MBinBuffer res;
+	if (!bSendIntro) {
+		bSendIntro = true;
+		res.append(intro_header, 4);
+	}
+
+	uint8_t buf[3];
+	size_t foo = cbLen;
+	for (int i = 0; i < 3; i++) {
+		buf[2 - i] = foo & 0xFF;
+		foo >>= 8;
+	}
+	res.append(buf, 3);
+	res.append(pData, cbLen);
+	return res;
+}
+
+MBinBuffer WANoise::encrypt(const void *pData, size_t cbLen)
+{
+	uint8_t iv[12];
+	generateIV(iv, writeCounter);
+
+	MBinBuffer res;
+	uint8_t outbuf[1024 + 64];
+
+	int enc_len = 0, final_len = 0;
+	EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+	EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, (BYTE *)encKey.data(), iv);
+
+	if (!bInitFinished)
+		EVP_EncryptUpdate(ctx, NULL, &enc_len, hash, sizeof(hash));
+	
+	for (size_t len = 0; len < cbLen; len += 1024) {
+		size_t portionSize = cbLen - len;
+		EVP_EncryptUpdate(ctx, outbuf, &enc_len, (BYTE *)pData + len, (int)min(portionSize, 1024));
+		res.append(outbuf, enc_len);
+	}
+	EVP_EncryptFinal_ex(ctx, outbuf, &final_len);
+	if (final_len)
+		res.append(outbuf, final_len);
+
+	uint8_t tag[16];
+	EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, sizeof(tag), tag);
+	res.append(tag, sizeof(tag));
+
+	EVP_CIPHER_CTX_free(ctx);
+
+	updateHash(res.data(), res.length());
+	return res;
+}
+
+void WANoise::updateHash(const void *pData, size_t cbLen)
+{
+	if (bInitFinished)
+		return;
+
+	SHA256_CTX ctx;
+	SHA256_Init(&ctx);
+	SHA256_Update(&ctx, hash, sizeof(hash));
+	SHA256_Update(&ctx, pData, cbLen);
+	SHA256_Final(hash, &ctx);
+}
diff --git a/protocols/WhatsApp/src/options.cpp b/protocols/WhatsApp/src/options.cpp
new file mode 100644
index 0000000000..0b9aaef264
--- /dev/null
+++ b/protocols/WhatsApp/src/options.cpp
@@ -0,0 +1,68 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+class COptionsDlg : public CProtoDlgBase<WhatsAppProto>
+{
+	CCtrlCheck chkHideChats;
+	CCtrlEdit edtGroup, edtNick;
+	ptrW m_wszOldGroup;
+
+public:
+	COptionsDlg(WhatsAppProto *ppro, int iDlgID, bool bFullDlg) :
+		CProtoDlgBase<WhatsAppProto>(ppro, iDlgID),
+		chkHideChats(this, IDC_HIDECHATS),
+		edtNick(this, IDC_NICK),
+		edtGroup(this, IDC_DEFGROUP),
+		m_wszOldGroup(mir_wstrdup(ppro->m_wszDefaultGroup))
+	{
+		CreateLink(edtNick, ppro->m_wszNick);
+		CreateLink(edtGroup, ppro->m_wszDefaultGroup);
+
+		if (bFullDlg)
+			CreateLink(chkHideChats, ppro->m_bHideGroupchats);
+	}
+
+	bool OnApply() override
+	{
+		if (mir_wstrlen(m_proto->m_wszNick)) {
+			SetFocus(edtNick.GetHwnd());
+			return false;
+		}
+
+		if (mir_wstrcmp(m_proto->m_wszDefaultGroup, m_wszOldGroup))
+			Clist_GroupCreate(0, m_proto->m_wszDefaultGroup);
+		return true;
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+INT_PTR WhatsAppProto::SvcCreateAccMgrUI(WPARAM, LPARAM hwndParent)
+{
+	auto *pDlg = new COptionsDlg(this, IDD_ACCMGRUI, false);
+	pDlg->SetParent((HWND)hwndParent);
+	pDlg->Create();
+	return (INT_PTR)pDlg->GetHwnd();
+}
+
+int WhatsAppProto::OnOptionsInit(WPARAM wParam, LPARAM)
+{
+	OPTIONSDIALOGPAGE odp = {};
+	odp.szTitle.w = m_tszUserName;
+	odp.flags = ODPF_UNICODE;
+	odp.szGroup.w = LPGENW("Network");
+
+	odp.position = 1;
+	odp.szTab.w = LPGENW("Account");
+	odp.pDialog = new COptionsDlg(this, IDD_OPTIONS, true);
+	g_plugin.addOptions(wParam, &odp);
+	return 0;
+}
diff --git a/protocols/WhatsApp/src/pmsg.pb.cc b/protocols/WhatsApp/src/pmsg.pb.cc
new file mode 100644
index 0000000000..6c4a99abc5
--- /dev/null
+++ b/protocols/WhatsApp/src/pmsg.pb.cc
@@ -0,0 +1,100321 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: pmsg.proto
+
+#include "pmsg.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 _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+namespace proto {
+PROTOBUF_CONSTEXPR ADVDeviceIdentity::ADVDeviceIdentity(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.timestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.rawid_)*/0u
+  , /*decltype(_impl_.keyindex_)*/0u} {}
+struct ADVDeviceIdentityDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ADVDeviceIdentityDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ADVDeviceIdentityDefaultTypeInternal() {}
+  union {
+    ADVDeviceIdentity _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_;
+PROTOBUF_CONSTEXPR ADVKeyIndexList::ADVKeyIndexList(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.validindexes_)*/{}
+  , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0}
+  , /*decltype(_impl_.timestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.rawid_)*/0u
+  , /*decltype(_impl_.currentindex_)*/0u} {}
+struct ADVKeyIndexListDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ADVKeyIndexListDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ADVKeyIndexListDefaultTypeInternal() {}
+  union {
+    ADVKeyIndexList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_;
+PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.accountsignaturekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.devicesignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ADVSignedDeviceIdentityDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ADVSignedDeviceIdentityDefaultTypeInternal() {}
+  union {
+    ADVSignedDeviceIdentity _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_;
+PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ADVSignedDeviceIdentityHMACDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMACDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ADVSignedDeviceIdentityHMACDefaultTypeInternal() {}
+  union {
+    ADVSignedDeviceIdentityHMAC _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_;
+PROTOBUF_CONSTEXPR ADVSignedKeyIndexList::ADVSignedKeyIndexList(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ADVSignedKeyIndexListDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ADVSignedKeyIndexListDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ADVSignedKeyIndexListDefaultTypeInternal() {}
+  union {
+    ADVSignedKeyIndexList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_;
+PROTOBUF_CONSTEXPR ActionLink::ActionLink(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.buttontitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ActionLinkDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ActionLinkDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ActionLinkDefaultTypeInternal() {}
+  union {
+    ActionLink _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionLinkDefaultTypeInternal _ActionLink_default_instance_;
+PROTOBUF_CONSTEXPR AutoDownloadSettings::AutoDownloadSettings(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.downloadimages_)*/false
+  , /*decltype(_impl_.downloadaudio_)*/false
+  , /*decltype(_impl_.downloadvideo_)*/false
+  , /*decltype(_impl_.downloaddocuments_)*/false} {}
+struct AutoDownloadSettingsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR AutoDownloadSettingsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~AutoDownloadSettingsDefaultTypeInternal() {}
+  union {
+    AutoDownloadSettings _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_;
+PROTOBUF_CONSTEXPR BizAccountLinkInfo::BizAccountLinkInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.whatsappacctnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.whatsappbizacctfbid_)*/uint64_t{0u}
+  , /*decltype(_impl_.issuetime_)*/uint64_t{0u}
+  , /*decltype(_impl_.hoststorage_)*/0
+  , /*decltype(_impl_.accounttype_)*/0} {}
+struct BizAccountLinkInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR BizAccountLinkInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~BizAccountLinkInfoDefaultTypeInternal() {}
+  union {
+    BizAccountLinkInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_;
+PROTOBUF_CONSTEXPR BizAccountPayload::BizAccountPayload(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.bizacctlinkinfo_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.vnamecert_)*/nullptr} {}
+struct BizAccountPayloadDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR BizAccountPayloadDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~BizAccountPayloadDefaultTypeInternal() {}
+  union {
+    BizAccountPayload _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_;
+PROTOBUF_CONSTEXPR BizIdentityInfo::BizIdentityInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.vnamecert_)*/nullptr
+  , /*decltype(_impl_.vlevel_)*/0
+  , /*decltype(_impl_.signed__)*/false
+  , /*decltype(_impl_.revoked_)*/false
+  , /*decltype(_impl_.hoststorage_)*/0
+  , /*decltype(_impl_.actualactors_)*/0
+  , /*decltype(_impl_.privacymodets_)*/uint64_t{0u}
+  , /*decltype(_impl_.featurecontrols_)*/uint64_t{0u}} {}
+struct BizIdentityInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR BizIdentityInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~BizIdentityInfoDefaultTypeInternal() {}
+  union {
+    BizIdentityInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_;
+PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.serial_)*/0u
+  , /*decltype(_impl_.issuerserial_)*/0u
+  , /*decltype(_impl_.notbefore_)*/uint64_t{0u}
+  , /*decltype(_impl_.notafter_)*/uint64_t{0u}} {}
+struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_DetailsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CertChain_NoiseCertificate_DetailsDefaultTypeInternal() {}
+  union {
+    CertChain_NoiseCertificate_Details _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_;
+PROTOBUF_CONSTEXPR CertChain_NoiseCertificate::CertChain_NoiseCertificate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct CertChain_NoiseCertificateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CertChain_NoiseCertificateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CertChain_NoiseCertificateDefaultTypeInternal() {}
+  union {
+    CertChain_NoiseCertificate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_;
+PROTOBUF_CONSTEXPR CertChain::CertChain(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.leaf_)*/nullptr
+  , /*decltype(_impl_.intermediate_)*/nullptr} {}
+struct CertChainDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CertChainDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CertChainDefaultTypeInternal() {}
+  union {
+    CertChain _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChainDefaultTypeInternal _CertChain_default_instance_;
+PROTOBUF_CONSTEXPR Chain::Chain(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagekeys_)*/{}
+  , /*decltype(_impl_.senderratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.senderratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.chainkey_)*/nullptr} {}
+struct ChainDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ChainDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ChainDefaultTypeInternal() {}
+  union {
+    Chain _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainDefaultTypeInternal _Chain_default_instance_;
+PROTOBUF_CONSTEXPR ChainKey::ChainKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.index_)*/0u} {}
+struct ChainKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ChainKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ChainKeyDefaultTypeInternal() {}
+  union {
+    ChainKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainKeyDefaultTypeInternal _ChainKey_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_DNSSource::ClientPayload_DNSSource(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.dnsmethod_)*/0
+  , /*decltype(_impl_.appcached_)*/false} {}
+struct ClientPayload_DNSSourceDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_DNSSourceDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_DNSSourceDefaultTypeInternal() {}
+  union {
+    ClientPayload_DNSSource _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.eregid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.ekeytype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.eident_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.eskeyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.eskeyval_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.eskeysig_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.buildhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.deviceprops_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal() {}
+  union {
+    ClientPayload_DevicePairingRegistrationData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.primary_)*/0u
+  , /*decltype(_impl_.secondary_)*/0u
+  , /*decltype(_impl_.tertiary_)*/0u
+  , /*decltype(_impl_.quaternary_)*/0u
+  , /*decltype(_impl_.quinary_)*/0u} {}
+struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_UserAgent_AppVersionDefaultTypeInternal() {}
+  union {
+    ClientPayload_UserAgent_AppVersion _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_UserAgent::ClientPayload_UserAgent(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mcc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mnc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.osversion_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.manufacturer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.osbuildnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.phoneid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localelanguageiso6391_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localecountryiso31661alpha2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.deviceboard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.appversion_)*/nullptr
+  , /*decltype(_impl_.platform_)*/0
+  , /*decltype(_impl_.releasechannel_)*/0} {}
+struct ClientPayload_UserAgentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_UserAgentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_UserAgentDefaultTypeInternal() {}
+  union {
+    ClientPayload_UserAgent _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.documenttypes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.features_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.usesparticipantinkey_)*/false
+  , /*decltype(_impl_.supportsstarredmessages_)*/false
+  , /*decltype(_impl_.supportsdocumentmessages_)*/false
+  , /*decltype(_impl_.supportsurlmessages_)*/false
+  , /*decltype(_impl_.supportsmediaretry_)*/false
+  , /*decltype(_impl_.supportse2eimage_)*/false
+  , /*decltype(_impl_.supportse2evideo_)*/false
+  , /*decltype(_impl_.supportse2eaudio_)*/false
+  , /*decltype(_impl_.supportse2edocument_)*/false} {}
+struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal() {}
+  union {
+    ClientPayload_WebInfo_WebdPayload _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload_WebInfo::ClientPayload_WebInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.reftoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.webdpayload_)*/nullptr
+  , /*decltype(_impl_.websubplatform_)*/0} {}
+struct ClientPayload_WebInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayload_WebInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayload_WebInfoDefaultTypeInternal() {}
+  union {
+    ClientPayload_WebInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_;
+PROTOBUF_CONSTEXPR ClientPayload::ClientPayload(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.shards_)*/{}
+  , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fbcat_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fbuseragent_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fbdeviceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.useragent_)*/nullptr
+  , /*decltype(_impl_.webinfo_)*/nullptr
+  , /*decltype(_impl_.dnssource_)*/nullptr
+  , /*decltype(_impl_.devicepairingdata_)*/nullptr
+  , /*decltype(_impl_.username_)*/uint64_t{0u}
+  , /*decltype(_impl_.sessionid_)*/0
+  , /*decltype(_impl_.connecttype_)*/0
+  , /*decltype(_impl_.connectreason_)*/0
+  , /*decltype(_impl_.connectattemptcount_)*/0u
+  , /*decltype(_impl_.passive_)*/false
+  , /*decltype(_impl_.shortconnect_)*/false
+  , /*decltype(_impl_.oc_)*/false
+  , /*decltype(_impl_.pull_)*/false
+  , /*decltype(_impl_.device_)*/0u
+  , /*decltype(_impl_.product_)*/0
+  , /*decltype(_impl_.lc_)*/0
+  , /*decltype(_impl_.fbappid_)*/uint64_t{0u}
+  , /*decltype(_impl_.iosappextension_)*/0} {}
+struct ClientPayloadDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPayloadDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPayloadDefaultTypeInternal() {}
+  union {
+    ClientPayload _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_;
+PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.advertisername_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediatype_)*/0} {}
+struct ContextInfo_AdReplyInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ContextInfo_AdReplyInfoDefaultTypeInternal() {}
+  union {
+    ContextInfo_AdReplyInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_;
+PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediaurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sourcetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sourceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sourceurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediatype_)*/0
+  , /*decltype(_impl_.containsautoreply_)*/false
+  , /*decltype(_impl_.renderlargerthumbnail_)*/false
+  , /*decltype(_impl_.showadattribution_)*/false} {}
+struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ContextInfo_ExternalAdReplyInfoDefaultTypeInternal() {}
+  union {
+    ContextInfo_ExternalAdReplyInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_;
+PROTOBUF_CONSTEXPR ContextInfo::ContextInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mentionedjid_)*/{}
+  , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.ephemeralsharedsecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.entrypointconversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.entrypointconversionapp_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.groupsubject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.parentgroupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.quotedmessage_)*/nullptr
+  , /*decltype(_impl_.quotedad_)*/nullptr
+  , /*decltype(_impl_.placeholderkey_)*/nullptr
+  , /*decltype(_impl_.externaladreply_)*/nullptr
+  , /*decltype(_impl_.disappearingmode_)*/nullptr
+  , /*decltype(_impl_.actionlink_)*/nullptr
+  , /*decltype(_impl_.conversiondelayseconds_)*/0u
+  , /*decltype(_impl_.forwardingscore_)*/0u
+  , /*decltype(_impl_.isforwarded_)*/false
+  , /*decltype(_impl_.expiration_)*/0u
+  , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.entrypointconversiondelayseconds_)*/0u} {}
+struct ContextInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ContextInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ContextInfoDefaultTypeInternal() {}
+  union {
+    ContextInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfoDefaultTypeInternal _ContextInfo_default_instance_;
+PROTOBUF_CONSTEXPR Conversation::Conversation(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messages_)*/{}
+  , /*decltype(_impl_.participant_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.newjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.oldjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.tctoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contactprimaryidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.createdby_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.parentgroupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pnjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.disappearingmode_)*/nullptr
+  , /*decltype(_impl_.wallpaper_)*/nullptr
+  , /*decltype(_impl_.lastmsgtimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.unreadcount_)*/0u
+  , /*decltype(_impl_.ephemeralexpiration_)*/0u
+  , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.endofhistorytransfertype_)*/0
+  , /*decltype(_impl_.readonly_)*/false
+  , /*decltype(_impl_.endofhistorytransfer_)*/false
+  , /*decltype(_impl_.notspam_)*/false
+  , /*decltype(_impl_.archived_)*/false
+  , /*decltype(_impl_.conversationtimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.unreadmentioncount_)*/0u
+  , /*decltype(_impl_.pinned_)*/0u
+  , /*decltype(_impl_.tctokentimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.muteendtime_)*/uint64_t{0u}
+  , /*decltype(_impl_.mediavisibility_)*/0
+  , /*decltype(_impl_.markedasunread_)*/false
+  , /*decltype(_impl_.suspended_)*/false
+  , /*decltype(_impl_.terminated_)*/false
+  , /*decltype(_impl_.support_)*/false
+  , /*decltype(_impl_.tctokensendertimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.createdat_)*/uint64_t{0u}
+  , /*decltype(_impl_.isparentgroup_)*/false
+  , /*decltype(_impl_.isdefaultsubgroup_)*/false
+  , /*decltype(_impl_.selfpnexposed_)*/false} {}
+struct ConversationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ConversationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ConversationDefaultTypeInternal() {}
+  union {
+    Conversation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConversationDefaultTypeInternal _Conversation_default_instance_;
+PROTOBUF_CONSTEXPR DeviceListMetadata::DeviceListMetadata(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.senderkeyindexes_)*/{}
+  , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0}
+  , /*decltype(_impl_.recipientkeyindexes_)*/{}
+  , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0}
+  , /*decltype(_impl_.senderkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.recipientkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sendertimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.recipienttimestamp_)*/uint64_t{0u}} {}
+struct DeviceListMetadataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR DeviceListMetadataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~DeviceListMetadataDefaultTypeInternal() {}
+  union {
+    DeviceListMetadata _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_;
+PROTOBUF_CONSTEXPR DeviceProps_AppVersion::DeviceProps_AppVersion(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.primary_)*/0u
+  , /*decltype(_impl_.secondary_)*/0u
+  , /*decltype(_impl_.tertiary_)*/0u
+  , /*decltype(_impl_.quaternary_)*/0u
+  , /*decltype(_impl_.quinary_)*/0u} {}
+struct DeviceProps_AppVersionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR DeviceProps_AppVersionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~DeviceProps_AppVersionDefaultTypeInternal() {}
+  union {
+    DeviceProps_AppVersion _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_;
+PROTOBUF_CONSTEXPR DeviceProps::DeviceProps(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.os_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/nullptr
+  , /*decltype(_impl_.platformtype_)*/0
+  , /*decltype(_impl_.requirefullsync_)*/false} {}
+struct DevicePropsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR DevicePropsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~DevicePropsDefaultTypeInternal() {}
+  union {
+    DeviceProps _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DevicePropsDefaultTypeInternal _DeviceProps_default_instance_;
+PROTOBUF_CONSTEXPR DisappearingMode::DisappearingMode(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.initiator_)*/0} {}
+struct DisappearingModeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR DisappearingModeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~DisappearingModeDefaultTypeInternal() {}
+  union {
+    DisappearingMode _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_;
+PROTOBUF_CONSTEXPR EphemeralSetting::EphemeralSetting(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}
+  , /*decltype(_impl_.duration_)*/0} {}
+struct EphemeralSettingDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR EphemeralSettingDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~EphemeralSettingDefaultTypeInternal() {}
+  union {
+    EphemeralSetting _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_;
+PROTOBUF_CONSTEXPR ExitCode::ExitCode(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.code_)*/uint64_t{0u}} {}
+struct ExitCodeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ExitCodeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ExitCodeDefaultTypeInternal() {}
+  union {
+    ExitCode _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExitCodeDefaultTypeInternal _ExitCode_default_instance_;
+PROTOBUF_CONSTEXPR ExternalBlobReference::ExternalBlobReference(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesizebytes_)*/uint64_t{0u}} {}
+struct ExternalBlobReferenceDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ExternalBlobReferenceDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ExternalBlobReferenceDefaultTypeInternal() {}
+  union {
+    ExternalBlobReference _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_;
+PROTOBUF_CONSTEXPR GlobalSettings::GlobalSettings(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.lightthemewallpaper_)*/nullptr
+  , /*decltype(_impl_.darkthemewallpaper_)*/nullptr
+  , /*decltype(_impl_.autodownloadwifi_)*/nullptr
+  , /*decltype(_impl_.autodownloadcellular_)*/nullptr
+  , /*decltype(_impl_.autodownloadroaming_)*/nullptr
+  , /*decltype(_impl_.mediavisibility_)*/0
+  , /*decltype(_impl_.showindividualnotificationspreview_)*/false
+  , /*decltype(_impl_.showgroupnotificationspreview_)*/false
+  , /*decltype(_impl_.disappearingmodetimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.disappearingmodeduration_)*/0} {}
+struct GlobalSettingsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR GlobalSettingsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~GlobalSettingsDefaultTypeInternal() {}
+  union {
+    GlobalSettings _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_;
+PROTOBUF_CONSTEXPR GroupParticipant::GroupParticipant(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.rank_)*/0} {}
+struct GroupParticipantDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR GroupParticipantDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~GroupParticipantDefaultTypeInternal() {}
+  union {
+    GroupParticipant _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_;
+PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HandshakeMessage_ClientFinishDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinishDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HandshakeMessage_ClientFinishDefaultTypeInternal() {}
+  union {
+    HandshakeMessage_ClientFinish _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_;
+PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HandshakeMessage_ClientHelloDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HandshakeMessage_ClientHelloDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HandshakeMessage_ClientHelloDefaultTypeInternal() {}
+  union {
+    HandshakeMessage_ClientHello _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_;
+PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HandshakeMessage_ServerHelloDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HandshakeMessage_ServerHelloDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HandshakeMessage_ServerHelloDefaultTypeInternal() {}
+  union {
+    HandshakeMessage_ServerHello _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_;
+PROTOBUF_CONSTEXPR HandshakeMessage::HandshakeMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.clienthello_)*/nullptr
+  , /*decltype(_impl_.serverhello_)*/nullptr
+  , /*decltype(_impl_.clientfinish_)*/nullptr} {}
+struct HandshakeMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HandshakeMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HandshakeMessageDefaultTypeInternal() {}
+  union {
+    HandshakeMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_;
+PROTOBUF_CONSTEXPR HistorySync::HistorySync(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.conversations_)*/{}
+  , /*decltype(_impl_.statusv3messages_)*/{}
+  , /*decltype(_impl_.pushnames_)*/{}
+  , /*decltype(_impl_.recentstickers_)*/{}
+  , /*decltype(_impl_.pastparticipants_)*/{}
+  , /*decltype(_impl_.threadidusersecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.globalsettings_)*/nullptr
+  , /*decltype(_impl_.synctype_)*/0
+  , /*decltype(_impl_.chunkorder_)*/0u
+  , /*decltype(_impl_.progress_)*/0u
+  , /*decltype(_impl_.threaddstimeframeoffset_)*/0u} {}
+struct HistorySyncDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HistorySyncDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HistorySyncDefaultTypeInternal() {}
+  union {
+    HistorySync _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncDefaultTypeInternal _HistorySync_default_instance_;
+PROTOBUF_CONSTEXPR HistorySyncMsg::HistorySyncMsg(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.message_)*/nullptr
+  , /*decltype(_impl_.msgorderid_)*/uint64_t{0u}} {}
+struct HistorySyncMsgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HistorySyncMsgDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HistorySyncMsgDefaultTypeInternal() {}
+  union {
+    HistorySyncMsg _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_;
+PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.phonenumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal() {}
+  union {
+    HydratedTemplateButton_HydratedCallButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_;
+PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal() {}
+  union {
+    HydratedTemplateButton_HydratedQuickReplyButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_;
+PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal() {}
+  union {
+    HydratedTemplateButton_HydratedURLButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_;
+PROTOBUF_CONSTEXPR HydratedTemplateButton::HydratedTemplateButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.index_)*/0u
+  , /*decltype(_impl_.hydratedButton_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct HydratedTemplateButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HydratedTemplateButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HydratedTemplateButtonDefaultTypeInternal() {}
+  union {
+    HydratedTemplateButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_;
+PROTOBUF_CONSTEXPR IdentityKeyPairStructure::IdentityKeyPairStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct IdentityKeyPairStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR IdentityKeyPairStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~IdentityKeyPairStructureDefaultTypeInternal() {}
+  union {
+    IdentityKeyPairStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_;
+PROTOBUF_CONSTEXPR InteractiveAnnotation::InteractiveAnnotation(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.polygonvertices_)*/{}
+  , /*decltype(_impl_.action_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct InteractiveAnnotationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR InteractiveAnnotationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~InteractiveAnnotationDefaultTypeInternal() {}
+  union {
+    InteractiveAnnotation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_;
+PROTOBUF_CONSTEXPR KeepInChat::KeepInChat(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.devicejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.servertimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.keeptype_)*/0} {}
+struct KeepInChatDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR KeepInChatDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~KeepInChatDefaultTypeInternal() {}
+  union {
+    KeepInChat _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeepInChatDefaultTypeInternal _KeepInChat_default_instance_;
+PROTOBUF_CONSTEXPR KeyId::KeyId(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct KeyIdDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR KeyIdDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~KeyIdDefaultTypeInternal() {}
+  union {
+    KeyId _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyIdDefaultTypeInternal _KeyId_default_instance_;
+PROTOBUF_CONSTEXPR LocalizedName::LocalizedName(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.lg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.lc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct LocalizedNameDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LocalizedNameDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LocalizedNameDefaultTypeInternal() {}
+  union {
+    LocalizedName _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_;
+PROTOBUF_CONSTEXPR Location::Location(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.degreeslatitude_)*/0
+  , /*decltype(_impl_.degreeslongitude_)*/0} {}
+struct LocationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LocationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LocationDefaultTypeInternal() {}
+  union {
+    Location _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocationDefaultTypeInternal _Location_default_instance_;
+PROTOBUF_CONSTEXPR MediaData::MediaData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.localpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct MediaDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MediaDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MediaDataDefaultTypeInternal() {}
+  union {
+    MediaData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaDataDefaultTypeInternal _MediaData_default_instance_;
+PROTOBUF_CONSTEXPR MediaRetryNotification::MediaRetryNotification(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.result_)*/0} {}
+struct MediaRetryNotificationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MediaRetryNotificationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MediaRetryNotificationDefaultTypeInternal() {}
+  union {
+    MediaRetryNotification _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.collectionnames_)*/{}
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}} {}
+struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotificationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateFatalExceptionNotificationDefaultTypeInternal() {}
+  union {
+    Message_AppStateFatalExceptionNotification _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.keydata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fingerprint_)*/nullptr
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}} {}
+struct Message_AppStateSyncKeyDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyDataDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKeyData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.deviceindexes_)*/{}
+  , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0}
+  , /*decltype(_impl_.rawid_)*/0u
+  , /*decltype(_impl_.currentindex_)*/0u} {}
+struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprintDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyFingerprintDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKeyFingerprint _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.keyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_AppStateSyncKeyIdDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyIdDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyIdDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKeyId _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.keyids_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct Message_AppStateSyncKeyRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyRequestDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKeyRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.keys_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct Message_AppStateSyncKeyShareDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShareDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyShareDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKeyShare _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_;
+PROTOBUF_CONSTEXPR Message_AppStateSyncKey::Message_AppStateSyncKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.keyid_)*/nullptr
+  , /*decltype(_impl_.keydata_)*/nullptr} {}
+struct Message_AppStateSyncKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AppStateSyncKeyDefaultTypeInternal() {}
+  union {
+    Message_AppStateSyncKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_;
+PROTOBUF_CONSTEXPR Message_AudioMessage::Message_AudioMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.waveform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.seconds_)*/0u
+  , /*decltype(_impl_.ptt_)*/false
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {}
+struct Message_AudioMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_AudioMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_AudioMessageDefaultTypeInternal() {}
+  union {
+    Message_AudioMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal() {}
+  union {
+    Message_ButtonsMessage_Button_ButtonText _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_;
+PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal() {}
+  union {
+    Message_ButtonsMessage_Button_NativeFlowInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_;
+PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.buttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.buttontext_)*/nullptr
+  , /*decltype(_impl_.nativeflowinfo_)*/nullptr
+  , /*decltype(_impl_.type_)*/0} {}
+struct Message_ButtonsMessage_ButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ButtonsMessage_ButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ButtonsMessage_ButtonDefaultTypeInternal() {}
+  union {
+    Message_ButtonsMessage_Button _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_;
+PROTOBUF_CONSTEXPR Message_ButtonsMessage::Message_ButtonsMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.buttons_)*/{}
+  , /*decltype(_impl_.contenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.headertype_)*/0
+  , /*decltype(_impl_.header_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_ButtonsMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ButtonsMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ButtonsMessageDefaultTypeInternal() {}
+  union {
+    Message_ButtonsMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.selectedbuttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.type_)*/0
+  , /*decltype(_impl_.response_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_ButtonsResponseMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ButtonsResponseMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ButtonsResponseMessageDefaultTypeInternal() {}
+  union {
+    Message_ButtonsResponseMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_Call::Message_Call(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.callkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.conversiondelayseconds_)*/0u} {}
+struct Message_CallDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_CallDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_CallDefaultTypeInternal() {}
+  union {
+    Message_Call _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CallDefaultTypeInternal _Message_Call_default_instance_;
+PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/nullptr} {}
+struct Message_CancelPaymentRequestMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_CancelPaymentRequestMessageDefaultTypeInternal() {}
+  union {
+    Message_CancelPaymentRequestMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_Chat::Message_Chat(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ChatDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ChatDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ChatDefaultTypeInternal() {}
+  union {
+    Message_Chat _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ChatDefaultTypeInternal _Message_Chat_default_instance_;
+PROTOBUF_CONSTEXPR Message_ContactMessage::Message_ContactMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.vcard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr} {}
+struct Message_ContactMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ContactMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ContactMessageDefaultTypeInternal() {}
+  union {
+    Message_ContactMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ContactsArrayMessage::Message_ContactsArrayMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.contacts_)*/{}
+  , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr} {}
+struct Message_ContactsArrayMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ContactsArrayMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ContactsArrayMessageDefaultTypeInternal() {}
+  union {
+    Message_ContactsArrayMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/nullptr} {}
+struct Message_DeclinePaymentRequestMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_DeclinePaymentRequestMessageDefaultTypeInternal() {}
+  union {
+    Message_DeclinePaymentRequestMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_DeviceSentMessage::Message_DeviceSentMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.destinationjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.message_)*/nullptr} {}
+struct Message_DeviceSentMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_DeviceSentMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_DeviceSentMessageDefaultTypeInternal() {}
+  union {
+    Message_DeviceSentMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_DocumentMessage::Message_DocumentMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.pagecount_)*/0u
+  , /*decltype(_impl_.contactvcard_)*/false
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.thumbnailheight_)*/0u
+  , /*decltype(_impl_.thumbnailwidth_)*/0u} {}
+struct Message_DocumentMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_DocumentMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_DocumentMessageDefaultTypeInternal() {}
+  union {
+    Message_DocumentMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ExtendedTextMessage::Message_ExtendedTextMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.invitelinkparentgroupsubjectv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.invitelinkparentgroupthumbnailv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.textargb_)*/0u
+  , /*decltype(_impl_.backgroundargb_)*/0u
+  , /*decltype(_impl_.font_)*/0
+  , /*decltype(_impl_.previewtype_)*/0
+  , /*decltype(_impl_.donotplayinline_)*/false
+  , /*decltype(_impl_.thumbnailheight_)*/0u
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.thumbnailwidth_)*/0u
+  , /*decltype(_impl_.invitelinkgrouptype_)*/0
+  , /*decltype(_impl_.invitelinkgrouptypev2_)*/0} {}
+struct Message_ExtendedTextMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ExtendedTextMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ExtendedTextMessageDefaultTypeInternal() {}
+  union {
+    Message_ExtendedTextMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_FutureProofMessage::Message_FutureProofMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.message_)*/nullptr} {}
+struct Message_FutureProofMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_FutureProofMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_FutureProofMessageDefaultTypeInternal() {}
+  union {
+    Message_FutureProofMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_GroupInviteMessage::Message_GroupInviteMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.invitecode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.groupname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.inviteexpiration_)*/int64_t{0}
+  , /*decltype(_impl_.grouptype_)*/0} {}
+struct Message_GroupInviteMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_GroupInviteMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_GroupInviteMessageDefaultTypeInternal() {}
+  union {
+    Message_GroupInviteMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.amount1000_)*/int64_t{0}} {}
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.year_)*/0u
+  , /*decltype(_impl_.month_)*/0u
+  , /*decltype(_impl_.dayofmonth_)*/0u
+  , /*decltype(_impl_.hour_)*/0u
+  , /*decltype(_impl_.minute_)*/0u
+  , /*decltype(_impl_.dayofweek_)*/1
+  , /*decltype(_impl_.calendar_)*/1} {}
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}} {}
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.datetimeOneof_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.default__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paramOneof_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_;
+PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.params_)*/{}
+  , /*decltype(_impl_.localizableparams_)*/{}
+  , /*decltype(_impl_.namespace__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.elementname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fallbacklg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fallbacklc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.deterministiclg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.deterministiclc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hydratedhsm_)*/nullptr} {}
+struct Message_HighlyStructuredMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HighlyStructuredMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HighlyStructuredMessageDefaultTypeInternal() {}
+  union {
+    Message_HighlyStructuredMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_HistorySyncNotification::Message_HistorySyncNotification(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.originalmessageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.synctype_)*/0
+  , /*decltype(_impl_.chunkorder_)*/0u
+  , /*decltype(_impl_.progress_)*/0u} {}
+struct Message_HistorySyncNotificationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_HistorySyncNotificationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_HistorySyncNotificationDefaultTypeInternal() {}
+  union {
+    Message_HistorySyncNotification _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_;
+PROTOBUF_CONSTEXPR Message_ImageMessage::Message_ImageMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.interactiveannotations_)*/{}
+  , /*decltype(_impl_.scanlengths_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstscansidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.scanssidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.midqualityfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.midqualityfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.firstscanlength_)*/0u
+  , /*decltype(_impl_.experimentgroupid_)*/0u
+  , /*decltype(_impl_.viewonce_)*/false} {}
+struct Message_ImageMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ImageMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ImageMessageDefaultTypeInternal() {}
+  union {
+    Message_ImageMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.securitynotificationenabled_)*/false} {}
+struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal() {}
+  union {
+    Message_InitialSecurityNotificationSettingSync _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_InteractiveMessage_BodyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_BodyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_BodyDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_Body _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.bizjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.messageversion_)*/0} {}
+struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_CollectionMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_CollectionMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_InteractiveMessage_FooterDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_FooterDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_FooterDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_Footer _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.subtitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hasmediaattachment_)*/false
+  , /*decltype(_impl_.media_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_InteractiveMessage_HeaderDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_HeaderDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_HeaderDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_Header _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.buttonparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.buttons_)*/{}
+  , /*decltype(_impl_.messageparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.messageversion_)*/0} {}
+struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_NativeFlowMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.surface_)*/0
+  , /*decltype(_impl_.messageversion_)*/0} {}
+struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessage_ShopMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage_ShopMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveMessage::Message_InteractiveMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.header_)*/nullptr
+  , /*decltype(_impl_.body_)*/nullptr
+  , /*decltype(_impl_.footer_)*/nullptr
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.interactiveMessage_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_InteractiveMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_BodyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveResponseMessage_BodyDefaultTypeInternal() {}
+  union {
+    Message_InteractiveResponseMessage_Body _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/0} {}
+struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveResponseMessage_NativeFlowResponseMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.body_)*/nullptr
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.interactiveResponseMessage_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_InteractiveResponseMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InteractiveResponseMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InteractiveResponseMessageDefaultTypeInternal() {}
+  union {
+    Message_InteractiveResponseMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_InvoiceMessage::Message_InvoiceMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.note_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentmimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentmediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentdirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentjpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.attachmentmediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.attachmenttype_)*/0} {}
+struct Message_InvoiceMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_InvoiceMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_InvoiceMessageDefaultTypeInternal() {}
+  union {
+    Message_InvoiceMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_KeepInChatMessage::Message_KeepInChatMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.timestampms_)*/int64_t{0}
+  , /*decltype(_impl_.keeptype_)*/0} {}
+struct Message_KeepInChatMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_KeepInChatMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_KeepInChatMessageDefaultTypeInternal() {}
+  union {
+    Message_KeepInChatMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_ProductListHeaderImageDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_ProductListHeaderImage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.productsections_)*/{}
+  , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.headerimage_)*/nullptr} {}
+struct Message_ListMessage_ProductListInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_ProductListInfoDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_ProductListInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.products_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListMessage_ProductSectionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_ProductSectionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_ProductSectionDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_ProductSection _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_Product::Message_ListMessage_Product(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListMessage_ProductDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_ProductDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_ProductDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_Product _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_Row::Message_ListMessage_Row(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.rowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListMessage_RowDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_RowDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_RowDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_Row _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage_Section::Message_ListMessage_Section(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.rows_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListMessage_SectionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessage_SectionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessage_SectionDefaultTypeInternal() {}
+  union {
+    Message_ListMessage_Section _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListMessage::Message_ListMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.sections_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.buttontext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.productlistinfo_)*/nullptr
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.listtype_)*/0} {}
+struct Message_ListMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListMessageDefaultTypeInternal() {}
+  union {
+    Message_ListMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.selectedrowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal() {}
+  union {
+    Message_ListResponseMessage_SingleSelectReply _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_;
+PROTOBUF_CONSTEXPR Message_ListResponseMessage::Message_ListResponseMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.singleselectreply_)*/nullptr
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.listtype_)*/0} {}
+struct Message_ListResponseMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ListResponseMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ListResponseMessageDefaultTypeInternal() {}
+  union {
+    Message_ListResponseMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_LiveLocationMessage::Message_LiveLocationMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.degreeslatitude_)*/0
+  , /*decltype(_impl_.degreeslongitude_)*/0
+  , /*decltype(_impl_.accuracyinmeters_)*/0u
+  , /*decltype(_impl_.speedinmps_)*/0
+  , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u
+  , /*decltype(_impl_.timeoffset_)*/0u
+  , /*decltype(_impl_.sequencenumber_)*/int64_t{0}} {}
+struct Message_LiveLocationMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_LiveLocationMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_LiveLocationMessageDefaultTypeInternal() {}
+  union {
+    Message_LiveLocationMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_LocationMessage::Message_LocationMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.address_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.comment_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.degreeslatitude_)*/0
+  , /*decltype(_impl_.degreeslongitude_)*/0
+  , /*decltype(_impl_.islive_)*/false
+  , /*decltype(_impl_.accuracyinmeters_)*/0u
+  , /*decltype(_impl_.speedinmps_)*/0
+  , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u} {}
+struct Message_LocationMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_LocationMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_LocationMessageDefaultTypeInternal() {}
+  union {
+    Message_LocationMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_OrderMessage::Message_OrderMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.orderid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.ordertitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sellerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.totalcurrencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.totalamount1000_)*/int64_t{0}
+  , /*decltype(_impl_.itemcount_)*/0
+  , /*decltype(_impl_.status_)*/1
+  , /*decltype(_impl_.surface_)*/1} {}
+struct Message_OrderMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_OrderMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_OrderMessageDefaultTypeInternal() {}
+  union {
+    Message_OrderMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_PaymentInviteMessage::Message_PaymentInviteMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.expirytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.servicetype_)*/0} {}
+struct Message_PaymentInviteMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PaymentInviteMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PaymentInviteMessageDefaultTypeInternal() {}
+  union {
+    Message_PaymentInviteMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.optionname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_PollCreationMessage_OptionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollCreationMessage_OptionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollCreationMessage_OptionDefaultTypeInternal() {}
+  union {
+    Message_PollCreationMessage_Option _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollCreationMessage::Message_PollCreationMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.options_)*/{}
+  , /*decltype(_impl_.enckey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.selectableoptionscount_)*/0u} {}
+struct Message_PollCreationMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollCreationMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollCreationMessageDefaultTypeInternal() {}
+  union {
+    Message_PollCreationMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollEncValue::Message_PollEncValue(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_PollEncValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollEncValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollEncValueDefaultTypeInternal() {}
+  union {
+    Message_PollEncValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(
+    ::_pbi::ConstantInitialized) {}
+struct Message_PollUpdateMessageMetadataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollUpdateMessageMetadataDefaultTypeInternal() {}
+  union {
+    Message_PollUpdateMessageMetadata _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollUpdateMessage::Message_PollUpdateMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pollcreationmessagekey_)*/nullptr
+  , /*decltype(_impl_.vote_)*/nullptr
+  , /*decltype(_impl_.metadata_)*/nullptr
+  , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {}
+struct Message_PollUpdateMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollUpdateMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollUpdateMessageDefaultTypeInternal() {}
+  union {
+    Message_PollUpdateMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_PollVoteMessage::Message_PollVoteMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.selectedoptions_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct Message_PollVoteMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_PollVoteMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_PollVoteMessageDefaultTypeInternal() {}
+  union {
+    Message_PollVoteMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.catalogimage_)*/nullptr} {}
+struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshotDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ProductMessage_CatalogSnapshotDefaultTypeInternal() {}
+  union {
+    Message_ProductMessage_CatalogSnapshot _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_;
+PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.retailerid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstimageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.productimage_)*/nullptr
+  , /*decltype(_impl_.priceamount1000_)*/int64_t{0}
+  , /*decltype(_impl_.salepriceamount1000_)*/int64_t{0}
+  , /*decltype(_impl_.productimagecount_)*/0u} {}
+struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshotDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ProductMessage_ProductSnapshotDefaultTypeInternal() {}
+  union {
+    Message_ProductMessage_ProductSnapshot _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_;
+PROTOBUF_CONSTEXPR Message_ProductMessage::Message_ProductMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.footer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.product_)*/nullptr
+  , /*decltype(_impl_.catalog_)*/nullptr
+  , /*decltype(_impl_.contextinfo_)*/nullptr} {}
+struct Message_ProductMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ProductMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ProductMessageDefaultTypeInternal() {}
+  union {
+    Message_ProductMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ProtocolMessage::Message_ProtocolMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.historysyncnotification_)*/nullptr
+  , /*decltype(_impl_.appstatesynckeyshare_)*/nullptr
+  , /*decltype(_impl_.appstatesynckeyrequest_)*/nullptr
+  , /*decltype(_impl_.initialsecuritynotificationsettingsync_)*/nullptr
+  , /*decltype(_impl_.appstatefatalexceptionnotification_)*/nullptr
+  , /*decltype(_impl_.disappearingmode_)*/nullptr
+  , /*decltype(_impl_.requestmediauploadmessage_)*/nullptr
+  , /*decltype(_impl_.requestmediauploadresponsemessage_)*/nullptr
+  , /*decltype(_impl_.type_)*/0
+  , /*decltype(_impl_.ephemeralexpiration_)*/0u
+  , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0}} {}
+struct Message_ProtocolMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ProtocolMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ProtocolMessageDefaultTypeInternal() {}
+  union {
+    Message_ProtocolMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_ReactionMessage::Message_ReactionMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {}
+struct Message_ReactionMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_ReactionMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_ReactionMessageDefaultTypeInternal() {}
+  union {
+    Message_ReactionMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.filesha256_)*/{}
+  , /*decltype(_impl_.rmrsource_)*/0} {}
+struct Message_RequestMediaUploadMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_RequestMediaUploadMessageDefaultTypeInternal() {}
+  union {
+    Message_RequestMediaUploadMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.stickermessage_)*/nullptr
+  , /*decltype(_impl_.mediauploadresult_)*/0} {}
+struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal() {}
+  union {
+    Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_;
+PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.reuploadresult_)*/{}
+  , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.rmrsource_)*/0} {}
+struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_RequestMediaUploadResponseMessageDefaultTypeInternal() {}
+  union {
+    Message_RequestMediaUploadResponseMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_RequestPaymentMessage::Message_RequestPaymentMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.currencycodeiso4217_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.requestfrom_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.notemessage_)*/nullptr
+  , /*decltype(_impl_.amount_)*/nullptr
+  , /*decltype(_impl_.background_)*/nullptr
+  , /*decltype(_impl_.amount1000_)*/uint64_t{0u}
+  , /*decltype(_impl_.expirytimestamp_)*/int64_t{0}} {}
+struct Message_RequestPaymentMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_RequestPaymentMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_RequestPaymentMessageDefaultTypeInternal() {}
+  union {
+    Message_RequestPaymentMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.contextinfo_)*/nullptr} {}
+struct Message_RequestPhoneNumberMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_RequestPhoneNumberMessageDefaultTypeInternal() {}
+  union {
+    Message_RequestPhoneNumberMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_SendPaymentMessage::Message_SendPaymentMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.notemessage_)*/nullptr
+  , /*decltype(_impl_.requestmessagekey_)*/nullptr
+  , /*decltype(_impl_.background_)*/nullptr} {}
+struct Message_SendPaymentMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_SendPaymentMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_SendPaymentMessageDefaultTypeInternal() {}
+  union {
+    Message_SendPaymentMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.groupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.axolotlsenderkeydistributionmessage_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct Message_SenderKeyDistributionMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_SenderKeyDistributionMessageDefaultTypeInternal() {}
+  union {
+    Message_SenderKeyDistributionMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_StickerMessage::Message_StickerMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstframesidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pngthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.firstframelength_)*/0u
+  , /*decltype(_impl_.isanimated_)*/false} {}
+struct Message_StickerMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_StickerMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_StickerMessageDefaultTypeInternal() {}
+  union {
+    Message_StickerMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.filehash_)*/{}
+  , /*decltype(_impl_.rmrsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.requesttimestamp_)*/int64_t{0}} {}
+struct Message_StickerSyncRMRMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_StickerSyncRMRMessageDefaultTypeInternal() {}
+  union {
+    Message_StickerSyncRMRMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.selectedid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.selecteddisplaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.selectedindex_)*/0u} {}
+struct Message_TemplateButtonReplyMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_TemplateButtonReplyMessageDefaultTypeInternal() {}
+  union {
+    Message_TemplateButtonReplyMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.buttons_)*/{}
+  , /*decltype(_impl_.content_)*/nullptr
+  , /*decltype(_impl_.footer_)*/nullptr
+  , /*decltype(_impl_.title_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_TemplateMessage_FourRowTemplateDefaultTypeInternal() {}
+  union {
+    Message_TemplateMessage_FourRowTemplate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_;
+PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.hydratedbuttons_)*/{}
+  , /*decltype(_impl_.hydratedcontenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hydratedfootertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.templateid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.title_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal() {}
+  union {
+    Message_TemplateMessage_HydratedFourRowTemplate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_;
+PROTOBUF_CONSTEXPR Message_TemplateMessage::Message_TemplateMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.hydratedtemplate_)*/nullptr
+  , /*decltype(_impl_.format_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct Message_TemplateMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_TemplateMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_TemplateMessageDefaultTypeInternal() {}
+  union {
+    Message_TemplateMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message_VideoMessage::Message_VideoMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.interactiveannotations_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.contextinfo_)*/nullptr
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.seconds_)*/0u
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.gifplayback_)*/false
+  , /*decltype(_impl_.viewonce_)*/false
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.gifattribution_)*/0} {}
+struct Message_VideoMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Message_VideoMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Message_VideoMessageDefaultTypeInternal() {}
+  union {
+    Message_VideoMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_;
+PROTOBUF_CONSTEXPR Message::Message(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.conversation_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.senderkeydistributionmessage_)*/nullptr
+  , /*decltype(_impl_.imagemessage_)*/nullptr
+  , /*decltype(_impl_.contactmessage_)*/nullptr
+  , /*decltype(_impl_.locationmessage_)*/nullptr
+  , /*decltype(_impl_.extendedtextmessage_)*/nullptr
+  , /*decltype(_impl_.documentmessage_)*/nullptr
+  , /*decltype(_impl_.audiomessage_)*/nullptr
+  , /*decltype(_impl_.videomessage_)*/nullptr
+  , /*decltype(_impl_.call_)*/nullptr
+  , /*decltype(_impl_.chat_)*/nullptr
+  , /*decltype(_impl_.protocolmessage_)*/nullptr
+  , /*decltype(_impl_.contactsarraymessage_)*/nullptr
+  , /*decltype(_impl_.highlystructuredmessage_)*/nullptr
+  , /*decltype(_impl_.fastratchetkeysenderkeydistributionmessage_)*/nullptr
+  , /*decltype(_impl_.sendpaymentmessage_)*/nullptr
+  , /*decltype(_impl_.livelocationmessage_)*/nullptr
+  , /*decltype(_impl_.requestpaymentmessage_)*/nullptr
+  , /*decltype(_impl_.declinepaymentrequestmessage_)*/nullptr
+  , /*decltype(_impl_.cancelpaymentrequestmessage_)*/nullptr
+  , /*decltype(_impl_.templatemessage_)*/nullptr
+  , /*decltype(_impl_.stickermessage_)*/nullptr
+  , /*decltype(_impl_.groupinvitemessage_)*/nullptr
+  , /*decltype(_impl_.templatebuttonreplymessage_)*/nullptr
+  , /*decltype(_impl_.productmessage_)*/nullptr
+  , /*decltype(_impl_.devicesentmessage_)*/nullptr
+  , /*decltype(_impl_.messagecontextinfo_)*/nullptr
+  , /*decltype(_impl_.listmessage_)*/nullptr
+  , /*decltype(_impl_.viewoncemessage_)*/nullptr
+  , /*decltype(_impl_.ordermessage_)*/nullptr
+  , /*decltype(_impl_.listresponsemessage_)*/nullptr
+  , /*decltype(_impl_.ephemeralmessage_)*/nullptr
+  , /*decltype(_impl_.invoicemessage_)*/nullptr
+  , /*decltype(_impl_.buttonsmessage_)*/nullptr
+  , /*decltype(_impl_.buttonsresponsemessage_)*/nullptr
+  , /*decltype(_impl_.paymentinvitemessage_)*/nullptr
+  , /*decltype(_impl_.interactivemessage_)*/nullptr
+  , /*decltype(_impl_.reactionmessage_)*/nullptr
+  , /*decltype(_impl_.stickersyncrmrmessage_)*/nullptr
+  , /*decltype(_impl_.interactiveresponsemessage_)*/nullptr
+  , /*decltype(_impl_.pollcreationmessage_)*/nullptr
+  , /*decltype(_impl_.pollupdatemessage_)*/nullptr
+  , /*decltype(_impl_.keepinchatmessage_)*/nullptr
+  , /*decltype(_impl_.documentwithcaptionmessage_)*/nullptr
+  , /*decltype(_impl_.requestphonenumbermessage_)*/nullptr
+  , /*decltype(_impl_.viewoncemessagev2_)*/nullptr} {}
+struct MessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MessageDefaultTypeInternal() {}
+  union {
+    Message _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageDefaultTypeInternal _Message_default_instance_;
+PROTOBUF_CONSTEXPR MessageContextInfo::MessageContextInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.devicelistmetadata_)*/nullptr
+  , /*decltype(_impl_.devicelistmetadataversion_)*/0} {}
+struct MessageContextInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MessageContextInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MessageContextInfoDefaultTypeInternal() {}
+  union {
+    MessageContextInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_;
+PROTOBUF_CONSTEXPR MessageKey::MessageKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fromme_)*/false} {}
+struct MessageKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MessageKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MessageKeyDefaultTypeInternal() {}
+  union {
+    MessageKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageKeyDefaultTypeInternal _MessageKey_default_instance_;
+PROTOBUF_CONSTEXPR Money::Money(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/int64_t{0}
+  , /*decltype(_impl_.offset_)*/0u} {}
+struct MoneyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MoneyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MoneyDefaultTypeInternal() {}
+  union {
+    Money _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoneyDefaultTypeInternal _Money_default_instance_;
+PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct MsgOpaqueData_PollOptionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MsgOpaqueData_PollOptionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MsgOpaqueData_PollOptionDefaultTypeInternal() {}
+  union {
+    MsgOpaqueData_PollOption _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_;
+PROTOBUF_CONSTEXPR MsgOpaqueData::MsgOpaqueData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.polloptions_)*/{}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.paymentnotemsgbody_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.futureproofbuffer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.clienturl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.loc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pollname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pollupdateparentkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.encpollvote_)*/nullptr
+  , /*decltype(_impl_.lng_)*/0
+  , /*decltype(_impl_.lat_)*/0
+  , /*decltype(_impl_.islive_)*/false
+  , /*decltype(_impl_.paymentamount1000_)*/0
+  , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}
+  , /*decltype(_impl_.pollselectableoptionscount_)*/0u} {}
+struct MsgOpaqueDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MsgOpaqueDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MsgOpaqueDataDefaultTypeInternal() {}
+  union {
+    MsgOpaqueData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_;
+PROTOBUF_CONSTEXPR MsgRowOpaqueData::MsgRowOpaqueData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.currentmsg_)*/nullptr
+  , /*decltype(_impl_.quotedmsg_)*/nullptr} {}
+struct MsgRowOpaqueDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR MsgRowOpaqueDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~MsgRowOpaqueDataDefaultTypeInternal() {}
+  union {
+    MsgRowOpaqueData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_;
+PROTOBUF_CONSTEXPR NoiseCertificate_Details::NoiseCertificate_Details(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.subject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.expires_)*/uint64_t{0u}
+  , /*decltype(_impl_.serial_)*/0u} {}
+struct NoiseCertificate_DetailsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NoiseCertificate_DetailsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NoiseCertificate_DetailsDefaultTypeInternal() {}
+  union {
+    NoiseCertificate_Details _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_;
+PROTOBUF_CONSTEXPR NoiseCertificate::NoiseCertificate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct NoiseCertificateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NoiseCertificateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NoiseCertificateDefaultTypeInternal() {}
+  union {
+    NoiseCertificate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_;
+PROTOBUF_CONSTEXPR NotificationMessageInfo::NotificationMessageInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.message_)*/nullptr
+  , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u}} {}
+struct NotificationMessageInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NotificationMessageInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NotificationMessageInfoDefaultTypeInternal() {}
+  union {
+    NotificationMessageInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_;
+PROTOBUF_CONSTEXPR PastParticipant::PastParticipant(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.leavets_)*/uint64_t{0u}
+  , /*decltype(_impl_.leavereason_)*/0} {}
+struct PastParticipantDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PastParticipantDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PastParticipantDefaultTypeInternal() {}
+  union {
+    PastParticipant _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantDefaultTypeInternal _PastParticipant_default_instance_;
+PROTOBUF_CONSTEXPR PastParticipants::PastParticipants(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pastparticipants_)*/{}
+  , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct PastParticipantsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PastParticipantsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PastParticipantsDefaultTypeInternal() {}
+  union {
+    PastParticipants _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_;
+PROTOBUF_CONSTEXPR PaymentBackground_MediaData::PaymentBackground_MediaData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {}
+struct PaymentBackground_MediaDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PaymentBackground_MediaDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PaymentBackground_MediaDataDefaultTypeInternal() {}
+  union {
+    PaymentBackground_MediaData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_;
+PROTOBUF_CONSTEXPR PaymentBackground::PaymentBackground(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediadata_)*/nullptr
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.placeholderargb_)*/0u
+  , /*decltype(_impl_.textargb_)*/0u
+  , /*decltype(_impl_.subtextargb_)*/0u
+  , /*decltype(_impl_.type_)*/0} {}
+struct PaymentBackgroundDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PaymentBackgroundDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PaymentBackgroundDefaultTypeInternal() {}
+  union {
+    PaymentBackground _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_;
+PROTOBUF_CONSTEXPR PaymentInfo::PaymentInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.receiverjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.currency_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.requestmessagekey_)*/nullptr
+  , /*decltype(_impl_.primaryamount_)*/nullptr
+  , /*decltype(_impl_.exchangeamount_)*/nullptr
+  , /*decltype(_impl_.amount1000_)*/uint64_t{0u}
+  , /*decltype(_impl_.currencydeprecated_)*/0
+  , /*decltype(_impl_.status_)*/0
+  , /*decltype(_impl_.transactiontimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.expirytimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.futureproofed_)*/false
+  , /*decltype(_impl_.usenovifiatformat_)*/false
+  , /*decltype(_impl_.txnstatus_)*/0} {}
+struct PaymentInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PaymentInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PaymentInfoDefaultTypeInternal() {}
+  union {
+    PaymentInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_;
+PROTOBUF_CONSTEXPR PendingKeyExchange::PendingKeyExchange(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.localbasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localbasekeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.localidentitykeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sequence_)*/0u} {}
+struct PendingKeyExchangeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PendingKeyExchangeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PendingKeyExchangeDefaultTypeInternal() {}
+  union {
+    PendingKeyExchange _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_;
+PROTOBUF_CONSTEXPR PendingPreKey::PendingPreKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.basekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.prekeyid_)*/0u
+  , /*decltype(_impl_.signedprekeyid_)*/0} {}
+struct PendingPreKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PendingPreKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PendingPreKeyDefaultTypeInternal() {}
+  union {
+    PendingPreKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_;
+PROTOBUF_CONSTEXPR PhotoChange::PhotoChange(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.oldphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.newphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.newphotoid_)*/0u} {}
+struct PhotoChangeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PhotoChangeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PhotoChangeDefaultTypeInternal() {}
+  union {
+    PhotoChange _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_;
+PROTOBUF_CONSTEXPR Point::Point(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.xdeprecated_)*/0
+  , /*decltype(_impl_.ydeprecated_)*/0
+  , /*decltype(_impl_.x_)*/0
+  , /*decltype(_impl_.y_)*/0} {}
+struct PointDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PointDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PointDefaultTypeInternal() {}
+  union {
+    Point _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointDefaultTypeInternal _Point_default_instance_;
+PROTOBUF_CONSTEXPR PollAdditionalMetadata::PollAdditionalMetadata(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pollinvalidated_)*/false} {}
+struct PollAdditionalMetadataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PollAdditionalMetadataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PollAdditionalMetadataDefaultTypeInternal() {}
+  union {
+    PollAdditionalMetadata _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_;
+PROTOBUF_CONSTEXPR PollEncValue::PollEncValue(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct PollEncValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PollEncValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PollEncValueDefaultTypeInternal() {}
+  union {
+    PollEncValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollEncValueDefaultTypeInternal _PollEncValue_default_instance_;
+PROTOBUF_CONSTEXPR PollUpdate::PollUpdate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pollupdatemessagekey_)*/nullptr
+  , /*decltype(_impl_.vote_)*/nullptr
+  , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {}
+struct PollUpdateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PollUpdateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PollUpdateDefaultTypeInternal() {}
+  union {
+    PollUpdate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollUpdateDefaultTypeInternal _PollUpdate_default_instance_;
+PROTOBUF_CONSTEXPR PreKeyRecordStructure::PreKeyRecordStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/0u} {}
+struct PreKeyRecordStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PreKeyRecordStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PreKeyRecordStructureDefaultTypeInternal() {}
+  union {
+    PreKeyRecordStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_;
+PROTOBUF_CONSTEXPR Pushname::Pushname(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct PushnameDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PushnameDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PushnameDefaultTypeInternal() {}
+  union {
+    Pushname _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PushnameDefaultTypeInternal _Pushname_default_instance_;
+PROTOBUF_CONSTEXPR Reaction::Reaction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}
+  , /*decltype(_impl_.unread_)*/false} {}
+struct ReactionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ReactionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ReactionDefaultTypeInternal() {}
+  union {
+    Reaction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReactionDefaultTypeInternal _Reaction_default_instance_;
+PROTOBUF_CONSTEXPR RecentEmojiWeight::RecentEmojiWeight(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.emoji_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.weight_)*/0} {}
+struct RecentEmojiWeightDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR RecentEmojiWeightDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~RecentEmojiWeightDefaultTypeInternal() {}
+  union {
+    RecentEmojiWeight _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_;
+PROTOBUF_CONSTEXPR RecordStructure::RecordStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.previoussessions_)*/{}
+  , /*decltype(_impl_.currentsession_)*/nullptr} {}
+struct RecordStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR RecordStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~RecordStructureDefaultTypeInternal() {}
+  union {
+    RecordStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecordStructureDefaultTypeInternal _RecordStructure_default_instance_;
+PROTOBUF_CONSTEXPR SenderChainKey::SenderChainKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.iteration_)*/0u} {}
+struct SenderChainKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SenderChainKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SenderChainKeyDefaultTypeInternal() {}
+  union {
+    SenderChainKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_;
+PROTOBUF_CONSTEXPR SenderKeyRecordStructure::SenderKeyRecordStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.senderkeystates_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct SenderKeyRecordStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SenderKeyRecordStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SenderKeyRecordStructureDefaultTypeInternal() {}
+  union {
+    SenderKeyRecordStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_;
+PROTOBUF_CONSTEXPR SenderKeyStateStructure::SenderKeyStateStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.sendermessagekeys_)*/{}
+  , /*decltype(_impl_.senderchainkey_)*/nullptr
+  , /*decltype(_impl_.sendersigningkey_)*/nullptr
+  , /*decltype(_impl_.senderkeyid_)*/0u} {}
+struct SenderKeyStateStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SenderKeyStateStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SenderKeyStateStructureDefaultTypeInternal() {}
+  union {
+    SenderKeyStateStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_;
+PROTOBUF_CONSTEXPR SenderMessageKey::SenderMessageKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.iteration_)*/0u} {}
+struct SenderMessageKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SenderMessageKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SenderMessageKeyDefaultTypeInternal() {}
+  union {
+    SenderMessageKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_;
+PROTOBUF_CONSTEXPR SenderSigningKey::SenderSigningKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.public__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.private__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SenderSigningKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SenderSigningKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SenderSigningKeyDefaultTypeInternal() {}
+  union {
+    SenderSigningKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_;
+PROTOBUF_CONSTEXPR ServerErrorReceipt::ServerErrorReceipt(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ServerErrorReceiptDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ServerErrorReceiptDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ServerErrorReceiptDefaultTypeInternal() {}
+  union {
+    ServerErrorReceipt _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_;
+PROTOBUF_CONSTEXPR SessionStructure::SessionStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.receiverchains_)*/{}
+  , /*decltype(_impl_.localidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.remoteidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.rootkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.alicebasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.senderchain_)*/nullptr
+  , /*decltype(_impl_.pendingkeyexchange_)*/nullptr
+  , /*decltype(_impl_.pendingprekey_)*/nullptr
+  , /*decltype(_impl_.sessionversion_)*/0u
+  , /*decltype(_impl_.previouscounter_)*/0u
+  , /*decltype(_impl_.remoteregistrationid_)*/0u
+  , /*decltype(_impl_.localregistrationid_)*/0u
+  , /*decltype(_impl_.needsrefresh_)*/false} {}
+struct SessionStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SessionStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SessionStructureDefaultTypeInternal() {}
+  union {
+    SessionStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SessionStructureDefaultTypeInternal _SessionStructure_default_instance_;
+PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.timestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.id_)*/0u} {}
+struct SignedPreKeyRecordStructureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SignedPreKeyRecordStructureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SignedPreKeyRecordStructureDefaultTypeInternal() {}
+  union {
+    SignedPreKeyRecordStructure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_;
+PROTOBUF_CONSTEXPR StatusPSA::StatusPSA(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.campaignid_)*/uint64_t{0u}
+  , /*decltype(_impl_.campaignexpirationtimestamp_)*/uint64_t{0u}} {}
+struct StatusPSADefaultTypeInternal {
+  PROTOBUF_CONSTEXPR StatusPSADefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~StatusPSADefaultTypeInternal() {}
+  union {
+    StatusPSA _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusPSADefaultTypeInternal _StatusPSA_default_instance_;
+PROTOBUF_CONSTEXPR StickerMetadata::StickerMetadata(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.weight_)*/0} {}
+struct StickerMetadataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR StickerMetadataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~StickerMetadataDefaultTypeInternal() {}
+  union {
+    StickerMetadata _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionData::SyncActionData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.index_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.padding_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/nullptr
+  , /*decltype(_impl_.version_)*/0} {}
+struct SyncActionDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionDataDefaultTypeInternal() {}
+  union {
+    SyncActionData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_AgentAction::SyncActionValue_AgentAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.deviceid_)*/0
+  , /*decltype(_impl_.isdeleted_)*/false} {}
+struct SyncActionValue_AgentActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_AgentActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_AgentActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_AgentAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.allowed_)*/false} {}
+struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal() {}
+  union {
+    SyncActionValue_AndroidUnsupportedActions _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagerange_)*/nullptr
+  , /*decltype(_impl_.archived_)*/false} {}
+struct SyncActionValue_ArchiveChatActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_ArchiveChatActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_ArchiveChatAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagerange_)*/nullptr} {}
+struct SyncActionValue_ClearChatActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_ClearChatActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_ClearChatActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_ClearChatAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_ContactAction::SyncActionValue_ContactAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.fullname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncActionValue_ContactActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_ContactActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_ContactActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_ContactAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagerange_)*/nullptr} {}
+struct SyncActionValue_DeleteChatActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_DeleteChatActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_DeleteChatAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagetimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.deletemedia_)*/false} {}
+struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_DeleteMessageForMeAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.expiredkeyepoch_)*/0} {}
+struct SyncActionValue_KeyExpirationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_KeyExpirationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_KeyExpirationDefaultTypeInternal() {}
+  union {
+    SyncActionValue_KeyExpiration _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.labeled_)*/false} {}
+struct SyncActionValue_LabelAssociationActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_LabelAssociationActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_LabelAssociationAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.color_)*/0
+  , /*decltype(_impl_.predefinedid_)*/0
+  , /*decltype(_impl_.deleted_)*/false} {}
+struct SyncActionValue_LabelEditActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_LabelEditActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_LabelEditActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_LabelEditAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.locale_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncActionValue_LocaleSettingDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_LocaleSettingDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_LocaleSettingDefaultTypeInternal() {}
+  union {
+    SyncActionValue_LocaleSetting _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagerange_)*/nullptr
+  , /*decltype(_impl_.read_)*/false} {}
+struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_MarkChatAsReadActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_MarkChatAsReadAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_MuteAction::SyncActionValue_MuteAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.muteendtimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.muted_)*/false} {}
+struct SyncActionValue_MuteActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_MuteActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_MuteActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_MuteAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_NuxAction::SyncActionValue_NuxAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.acknowledged_)*/false} {}
+struct SyncActionValue_NuxActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_NuxActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_NuxActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_NuxAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_PinAction::SyncActionValue_PinAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pinned_)*/false} {}
+struct SyncActionValue_PinActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_PinActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_PinActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_PinAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.flags_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct SyncActionValue_PrimaryFeatureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeatureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_PrimaryFeatureDefaultTypeInternal() {}
+  union {
+    SyncActionValue_PrimaryFeature _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_PrimaryVersionActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_PrimaryVersionAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncActionValue_PushNameSettingDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_PushNameSettingDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_PushNameSettingDefaultTypeInternal() {}
+  union {
+    SyncActionValue_PushNameSetting _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.keywords_)*/{}
+  , /*decltype(_impl_.shortcut_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.count_)*/0
+  , /*decltype(_impl_.deleted_)*/false} {}
+struct SyncActionValue_QuickReplyActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_QuickReplyActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_QuickReplyAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.weights_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_RecentEmojiWeightsAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.shownotification_)*/false} {}
+struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSettingDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_SecurityNotificationSettingDefaultTypeInternal() {}
+  union {
+    SyncActionValue_SecurityNotificationSetting _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_StarAction::SyncActionValue_StarAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.starred_)*/false} {}
+struct SyncActionValue_StarActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_StarActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_StarActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_StarAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_StickerAction::SyncActionValue_StickerAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.height_)*/0u
+  , /*decltype(_impl_.width_)*/0u
+  , /*decltype(_impl_.filelength_)*/uint64_t{0u}
+  , /*decltype(_impl_.isfavorite_)*/false
+  , /*decltype(_impl_.deviceidhint_)*/0u} {}
+struct SyncActionValue_StickerActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_StickerActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_StickerActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_StickerAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.expirationdate_)*/int64_t{0}
+  , /*decltype(_impl_.isdeactivated_)*/false
+  , /*decltype(_impl_.isautorenewing_)*/false} {}
+struct SyncActionValue_SubscriptionActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_SubscriptionActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_SubscriptionAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messages_)*/{}
+  , /*decltype(_impl_.lastmessagetimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.lastsystemmessagetimestamp_)*/int64_t{0}} {}
+struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRangeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_SyncActionMessageRangeDefaultTypeInternal() {}
+  union {
+    SyncActionValue_SyncActionMessageRange _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}} {}
+struct SyncActionValue_SyncActionMessageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_SyncActionMessageDefaultTypeInternal() {}
+  union {
+    SyncActionValue_SyncActionMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.istwentyfourhourformatenabled_)*/false} {}
+struct SyncActionValue_TimeFormatActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_TimeFormatActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_TimeFormatAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.unarchivechats_)*/false} {}
+struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal() {}
+  union {
+    SyncActionValue_UnarchiveChatsSetting _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.muted_)*/false} {}
+struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteActionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValue_UserStatusMuteActionDefaultTypeInternal() {}
+  union {
+    SyncActionValue_UserStatusMuteAction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_;
+PROTOBUF_CONSTEXPR SyncActionValue::SyncActionValue(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.staraction_)*/nullptr
+  , /*decltype(_impl_.contactaction_)*/nullptr
+  , /*decltype(_impl_.muteaction_)*/nullptr
+  , /*decltype(_impl_.pinaction_)*/nullptr
+  , /*decltype(_impl_.securitynotificationsetting_)*/nullptr
+  , /*decltype(_impl_.pushnamesetting_)*/nullptr
+  , /*decltype(_impl_.quickreplyaction_)*/nullptr
+  , /*decltype(_impl_.recentemojiweightsaction_)*/nullptr
+  , /*decltype(_impl_.labeleditaction_)*/nullptr
+  , /*decltype(_impl_.labelassociationaction_)*/nullptr
+  , /*decltype(_impl_.localesetting_)*/nullptr
+  , /*decltype(_impl_.archivechataction_)*/nullptr
+  , /*decltype(_impl_.deletemessageformeaction_)*/nullptr
+  , /*decltype(_impl_.keyexpiration_)*/nullptr
+  , /*decltype(_impl_.markchatasreadaction_)*/nullptr
+  , /*decltype(_impl_.clearchataction_)*/nullptr
+  , /*decltype(_impl_.deletechataction_)*/nullptr
+  , /*decltype(_impl_.unarchivechatssetting_)*/nullptr
+  , /*decltype(_impl_.primaryfeature_)*/nullptr
+  , /*decltype(_impl_.androidunsupportedactions_)*/nullptr
+  , /*decltype(_impl_.agentaction_)*/nullptr
+  , /*decltype(_impl_.subscriptionaction_)*/nullptr
+  , /*decltype(_impl_.userstatusmuteaction_)*/nullptr
+  , /*decltype(_impl_.timeformataction_)*/nullptr
+  , /*decltype(_impl_.nuxaction_)*/nullptr
+  , /*decltype(_impl_.primaryversionaction_)*/nullptr
+  , /*decltype(_impl_.stickeraction_)*/nullptr
+  , /*decltype(_impl_.timestamp_)*/int64_t{0}} {}
+struct SyncActionValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncActionValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncActionValueDefaultTypeInternal() {}
+  union {
+    SyncActionValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_;
+PROTOBUF_CONSTEXPR SyncdIndex::SyncdIndex(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncdIndexDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdIndexDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdIndexDefaultTypeInternal() {}
+  union {
+    SyncdIndex _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_;
+PROTOBUF_CONSTEXPR SyncdMutation::SyncdMutation(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.record_)*/nullptr
+  , /*decltype(_impl_.operation_)*/0} {}
+struct SyncdMutationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdMutationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdMutationDefaultTypeInternal() {}
+  union {
+    SyncdMutation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_;
+PROTOBUF_CONSTEXPR SyncdMutations::SyncdMutations(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.mutations_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct SyncdMutationsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdMutationsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdMutationsDefaultTypeInternal() {}
+  union {
+    SyncdMutations _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_;
+PROTOBUF_CONSTEXPR SyncdPatch::SyncdPatch(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mutations_)*/{}
+  , /*decltype(_impl_.snapshotmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.patchmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/nullptr
+  , /*decltype(_impl_.externalmutations_)*/nullptr
+  , /*decltype(_impl_.keyid_)*/nullptr
+  , /*decltype(_impl_.exitcode_)*/nullptr
+  , /*decltype(_impl_.deviceindex_)*/0u} {}
+struct SyncdPatchDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdPatchDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdPatchDefaultTypeInternal() {}
+  union {
+    SyncdPatch _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_;
+PROTOBUF_CONSTEXPR SyncdRecord::SyncdRecord(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.index_)*/nullptr
+  , /*decltype(_impl_.value_)*/nullptr
+  , /*decltype(_impl_.keyid_)*/nullptr} {}
+struct SyncdRecordDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdRecordDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdRecordDefaultTypeInternal() {}
+  union {
+    SyncdRecord _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_;
+PROTOBUF_CONSTEXPR SyncdSnapshot::SyncdSnapshot(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.records_)*/{}
+  , /*decltype(_impl_.mac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/nullptr
+  , /*decltype(_impl_.keyid_)*/nullptr} {}
+struct SyncdSnapshotDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdSnapshotDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdSnapshotDefaultTypeInternal() {}
+  union {
+    SyncdSnapshot _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_;
+PROTOBUF_CONSTEXPR SyncdValue::SyncdValue(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct SyncdValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdValueDefaultTypeInternal() {}
+  union {
+    SyncdValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdValueDefaultTypeInternal _SyncdValue_default_instance_;
+PROTOBUF_CONSTEXPR SyncdVersion::SyncdVersion(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.version_)*/uint64_t{0u}} {}
+struct SyncdVersionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR SyncdVersionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~SyncdVersionDefaultTypeInternal() {}
+  union {
+    SyncdVersion _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_;
+PROTOBUF_CONSTEXPR TemplateButton_CallButton::TemplateButton_CallButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/nullptr
+  , /*decltype(_impl_.phonenumber_)*/nullptr} {}
+struct TemplateButton_CallButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TemplateButton_CallButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TemplateButton_CallButtonDefaultTypeInternal() {}
+  union {
+    TemplateButton_CallButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_;
+PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.displaytext_)*/nullptr} {}
+struct TemplateButton_QuickReplyButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TemplateButton_QuickReplyButtonDefaultTypeInternal() {}
+  union {
+    TemplateButton_QuickReplyButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_;
+PROTOBUF_CONSTEXPR TemplateButton_URLButton::TemplateButton_URLButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.displaytext_)*/nullptr
+  , /*decltype(_impl_.url_)*/nullptr} {}
+struct TemplateButton_URLButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TemplateButton_URLButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TemplateButton_URLButtonDefaultTypeInternal() {}
+  union {
+    TemplateButton_URLButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_;
+PROTOBUF_CONSTEXPR TemplateButton::TemplateButton(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.index_)*/0u
+  , /*decltype(_impl_.button_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct TemplateButtonDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TemplateButtonDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TemplateButtonDefaultTypeInternal() {}
+  union {
+    TemplateButton _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_;
+PROTOBUF_CONSTEXPR UserReceipt::UserReceipt(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.pendingdevicejid_)*/{}
+  , /*decltype(_impl_.delivereddevicejid_)*/{}
+  , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.receipttimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.readtimestamp_)*/int64_t{0}
+  , /*decltype(_impl_.playedtimestamp_)*/int64_t{0}} {}
+struct UserReceiptDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR UserReceiptDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~UserReceiptDefaultTypeInternal() {}
+  union {
+    UserReceipt _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserReceiptDefaultTypeInternal _UserReceipt_default_instance_;
+PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.localizednames_)*/{}
+  , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.serial_)*/uint64_t{0u}
+  , /*decltype(_impl_.issuetime_)*/uint64_t{0u}} {}
+struct VerifiedNameCertificate_DetailsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR VerifiedNameCertificate_DetailsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~VerifiedNameCertificate_DetailsDefaultTypeInternal() {}
+  union {
+    VerifiedNameCertificate_Details _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_;
+PROTOBUF_CONSTEXPR VerifiedNameCertificate::VerifiedNameCertificate(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.serversignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct VerifiedNameCertificateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR VerifiedNameCertificateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~VerifiedNameCertificateDefaultTypeInternal() {}
+  union {
+    VerifiedNameCertificate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_;
+PROTOBUF_CONSTEXPR WallpaperSettings::WallpaperSettings(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.opacity_)*/0u} {}
+struct WallpaperSettingsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR WallpaperSettingsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~WallpaperSettingsDefaultTypeInternal() {}
+  union {
+    WallpaperSettings _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_;
+PROTOBUF_CONSTEXPR WebFeatures::WebFeatures(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.labelsdisplay_)*/0
+  , /*decltype(_impl_.voipindividualoutgoing_)*/0
+  , /*decltype(_impl_.groupsv3_)*/0
+  , /*decltype(_impl_.groupsv3create_)*/0
+  , /*decltype(_impl_.changenumberv2_)*/0
+  , /*decltype(_impl_.querystatusv3thumbnail_)*/0
+  , /*decltype(_impl_.livelocations_)*/0
+  , /*decltype(_impl_.queryvname_)*/0
+  , /*decltype(_impl_.voipindividualincoming_)*/0
+  , /*decltype(_impl_.quickrepliesquery_)*/0
+  , /*decltype(_impl_.payments_)*/0
+  , /*decltype(_impl_.stickerpackquery_)*/0
+  , /*decltype(_impl_.livelocationsfinal_)*/0
+  , /*decltype(_impl_.labelsedit_)*/0
+  , /*decltype(_impl_.mediaupload_)*/0
+  , /*decltype(_impl_.mediauploadrichquickreplies_)*/0
+  , /*decltype(_impl_.vnamev2_)*/0
+  , /*decltype(_impl_.videoplaybackurl_)*/0
+  , /*decltype(_impl_.statusranking_)*/0
+  , /*decltype(_impl_.voipindividualvideo_)*/0
+  , /*decltype(_impl_.thirdpartystickers_)*/0
+  , /*decltype(_impl_.frequentlyforwardedsetting_)*/0
+  , /*decltype(_impl_.groupsv4joinpermission_)*/0
+  , /*decltype(_impl_.recentstickers_)*/0
+  , /*decltype(_impl_.catalog_)*/0
+  , /*decltype(_impl_.starredstickers_)*/0
+  , /*decltype(_impl_.voipgroupcall_)*/0
+  , /*decltype(_impl_.templatemessage_)*/0
+  , /*decltype(_impl_.templatemessageinteractivity_)*/0
+  , /*decltype(_impl_.ephemeralmessages_)*/0
+  , /*decltype(_impl_.e2enotificationsync_)*/0
+  , /*decltype(_impl_.recentstickersv2_)*/0
+  , /*decltype(_impl_.recentstickersv3_)*/0
+  , /*decltype(_impl_.usernotice_)*/0
+  , /*decltype(_impl_.support_)*/0
+  , /*decltype(_impl_.groupuiicleanup_)*/0
+  , /*decltype(_impl_.groupdogfoodinginternalonly_)*/0
+  , /*decltype(_impl_.settingssync_)*/0
+  , /*decltype(_impl_.archivev2_)*/0
+  , /*decltype(_impl_.ephemeralallowgroupmembers_)*/0
+  , /*decltype(_impl_.ephemeral24hduration_)*/0
+  , /*decltype(_impl_.mdforceupgrade_)*/0
+  , /*decltype(_impl_.disappearingmode_)*/0
+  , /*decltype(_impl_.externalmdoptinavailable_)*/0
+  , /*decltype(_impl_.nodeletemessagetimelimit_)*/0} {}
+struct WebFeaturesDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR WebFeaturesDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~WebFeaturesDefaultTypeInternal() {}
+  union {
+    WebFeatures _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_;
+PROTOBUF_CONSTEXPR WebMessageInfo::WebMessageInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.messagestubparameters_)*/{}
+  , /*decltype(_impl_.labels_)*/{}
+  , /*decltype(_impl_.userreceipt_)*/{}
+  , /*decltype(_impl_.reactions_)*/{}
+  , /*decltype(_impl_.pollupdates_)*/{}
+  , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mediaciphertextsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.verifiedbizname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.futureproofdata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.agentid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.originalselfauthoruserjidstring_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.key_)*/nullptr
+  , /*decltype(_impl_.message_)*/nullptr
+  , /*decltype(_impl_.paymentinfo_)*/nullptr
+  , /*decltype(_impl_.finallivelocation_)*/nullptr
+  , /*decltype(_impl_.quotedpaymentinfo_)*/nullptr
+  , /*decltype(_impl_.mediadata_)*/nullptr
+  , /*decltype(_impl_.photochange_)*/nullptr
+  , /*decltype(_impl_.quotedstickerdata_)*/nullptr
+  , /*decltype(_impl_.statuspsa_)*/nullptr
+  , /*decltype(_impl_.polladditionalmetadata_)*/nullptr
+  , /*decltype(_impl_.keepinchat_)*/nullptr
+  , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.messagec2stimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.status_)*/0
+  , /*decltype(_impl_.ignore_)*/false
+  , /*decltype(_impl_.starred_)*/false
+  , /*decltype(_impl_.broadcast_)*/false
+  , /*decltype(_impl_.multicast_)*/false
+  , /*decltype(_impl_.messagestubtype_)*/0
+  , /*decltype(_impl_.urltext_)*/false
+  , /*decltype(_impl_.urlnumber_)*/false
+  , /*decltype(_impl_.clearmedia_)*/false
+  , /*decltype(_impl_.ephemeralofftoon_)*/false
+  , /*decltype(_impl_.duration_)*/0u
+  , /*decltype(_impl_.ephemeralduration_)*/0u
+  , /*decltype(_impl_.ephemeralstarttimestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.bizprivacystatus_)*/0
+  , /*decltype(_impl_.ephemeraloutofsync_)*/false
+  , /*decltype(_impl_.statusalreadyviewed_)*/false
+  , /*decltype(_impl_.revokemessagetimestamp_)*/uint64_t{0u}} {}
+struct WebMessageInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR WebMessageInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~WebMessageInfoDefaultTypeInternal() {}
+  union {
+    WebMessageInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_;
+PROTOBUF_CONSTEXPR WebNotificationsInfo::WebNotificationsInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.notifymessages_)*/{}
+  , /*decltype(_impl_.timestamp_)*/uint64_t{0u}
+  , /*decltype(_impl_.unreadchats_)*/0u
+  , /*decltype(_impl_.notifymessagecount_)*/0u} {}
+struct WebNotificationsInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR WebNotificationsInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~WebNotificationsInfoDefaultTypeInternal() {}
+  union {
+    WebNotificationsInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_;
+}  // namespace proto
+static ::_pb::Metadata file_level_metadata_pmsg_2eproto[224];
+static const ::_pb::EnumDescriptor* file_level_enum_descriptors_pmsg_2eproto[53];
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_pmsg_2eproto = nullptr;
+
+const uint32_t TableStruct_pmsg_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.rawid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.timestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.keyindex_),
+  1,
+  0,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.rawid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.timestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.currentindex_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.validindexes_),
+  1,
+  0,
+  2,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignaturekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignature_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.devicesignature_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.hmac_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.accountsignature_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.buttontitle_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadimages_),
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadaudio_),
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadvideo_),
+  PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloaddocuments_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappbizacctfbid_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappacctnumber_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.issuetime_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.hoststorage_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.accounttype_),
+  1,
+  0,
+  2,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.vnamecert_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.bizacctlinkinfo_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vlevel_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vnamecert_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.signed__),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.revoked_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.hoststorage_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.actualactors_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.privacymodets_),
+  PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.featurecontrols_),
+  1,
+  0,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.serial_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.issuerserial_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notbefore_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notafter_),
+  1,
+  2,
+  0,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.signature_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.leaf_),
+  PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.intermediate_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkeyprivate_),
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.chainkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.messagekeys_),
+  0,
+  1,
+  2,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.index_),
+  PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.key_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.dnsmethod_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.appcached_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eregid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.ekeytype_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eident_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyval_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeysig_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.buildhash_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.deviceprops_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.primary_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.secondary_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.tertiary_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quaternary_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quinary_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.platform_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.appversion_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mcc_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mnc_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osversion_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.manufacturer_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.device_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osbuildnumber_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.phoneid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.releasechannel_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localelanguageiso6391_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localecountryiso31661alpha2_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.deviceboard_),
+  11,
+  10,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  12,
+  7,
+  8,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsstarredmessages_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsdocumentmessages_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsurlmessages_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsmediaretry_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eimage_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2evideo_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eaudio_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.documenttypes_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.features_),
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.reftoken_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.webdpayload_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.websubplatform_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.username_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.passive_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.useragent_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.webinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pushname_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.sessionid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shortconnect_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connecttype_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectreason_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shards_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.dnssource_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectattemptcount_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.device_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.devicepairingdata_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.product_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbcat_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbuseragent_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.oc_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.lc_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.iosappextension_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbappid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbdeviceid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pull_),
+  PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.paddingbytes_),
+  9,
+  14,
+  5,
+  6,
+  0,
+  10,
+  15,
+  11,
+  12,
+  ~0u,
+  7,
+  13,
+  18,
+  8,
+  19,
+  1,
+  2,
+  16,
+  20,
+  22,
+  21,
+  3,
+  17,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.advertisername_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.mediatype_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.caption_),
+  0,
+  3,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnailurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediaurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourcetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.containsautoreply_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.renderlargerthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_),
+  0,
+  1,
+  8,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  9,
+  10,
+  11,
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.stanzaid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.participant_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.remotejid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.mentionedjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversionsource_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondata_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondelayseconds_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.forwardingscore_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.isforwarded_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedad_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.placeholderkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.expiration_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsettingtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsharedsecret_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.externaladreply_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionsource_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionapp_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversiondelayseconds_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.disappearingmode_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.actionlink_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.groupsubject_),
+  PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.parentgroupjid_),
+  0,
+  1,
+  10,
+  2,
+  ~0u,
+  3,
+  4,
+  16,
+  17,
+  18,
+  11,
+  12,
+  19,
+  20,
+  5,
+  13,
+  6,
+  7,
+  21,
+  14,
+  15,
+  8,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.messages_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.newjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.oldjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.lastmsgtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadcount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.readonly_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfer_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralexpiration_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralsettingtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfertype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.conversationtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.phash_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.notspam_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.archived_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.disappearingmode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadmentioncount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.markedasunread_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.participant_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctoken_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokentimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.contactprimaryidentitykey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pinned_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.muteendtime_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.wallpaper_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.mediavisibility_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokensendertimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.suspended_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.terminated_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdat_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdby_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.support_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isparentgroup_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isdefaultsubgroup_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.parentgroupid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.displayname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pnjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.selfpnexposed_),
+  0,
+  ~0u,
+  1,
+  2,
+  14,
+  15,
+  19,
+  20,
+  16,
+  17,
+  18,
+  23,
+  3,
+  4,
+  21,
+  22,
+  12,
+  24,
+  29,
+  ~0u,
+  5,
+  26,
+  6,
+  25,
+  27,
+  13,
+  28,
+  33,
+  30,
+  31,
+  34,
+  7,
+  8,
+  32,
+  35,
+  36,
+  9,
+  10,
+  11,
+  37,
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyhash_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.sendertimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyindexes_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyhash_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipienttimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyindexes_),
+  0,
+  2,
+  ~0u,
+  1,
+  3,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.primary_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.secondary_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.tertiary_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quaternary_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quinary_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.os_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.platformtype_),
+  PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.requirefullsync_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_.initiator_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.duration_),
+  PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.timestamp_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.code_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.text_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.handle_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesizebytes_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.fileencsha256_),
+  0,
+  1,
+  2,
+  5,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.lightthemewallpaper_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.mediavisibility_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.darkthemewallpaper_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadwifi_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadcellular_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadroaming_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showindividualnotificationspreview_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showgroupnotificationspreview_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodeduration_),
+  PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodetimestamp_),
+  0,
+  5,
+  1,
+  2,
+  3,
+  4,
+  6,
+  7,
+  9,
+  8,
+  PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.userjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.rank_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.static__),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.payload_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.ephemeral_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.static__),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.payload_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.ephemeral_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.static__),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.payload_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clienthello_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.serverhello_),
+  PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clientfinish_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.synctype_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.conversations_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.statusv3messages_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.chunkorder_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.progress_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pushnames_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.globalsettings_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threadidusersecret_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threaddstimeframeoffset_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.recentstickers_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pastparticipants_),
+  2,
+  ~0u,
+  ~0u,
+  3,
+  4,
+  ~0u,
+  1,
+  0,
+  5,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.msgorderid_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.phonenumber_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.id_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.url_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.index_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.hydratedButton_),
+  0,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.publickey_),
+  PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.privatekey_),
+  0,
+  1,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.polygonvertices_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.action_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.keeptype_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.servertimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.devicejid_),
+  3,
+  2,
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::KeyId, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_.id_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lg_),
+  PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lc_),
+  PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.verifiedname_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Location, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslatitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslongitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.name_),
+  1,
+  2,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MediaData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_.localpath_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.stanzaid_),
+  PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.result_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.collectionnames_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.timestamp_),
+  ~0u,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.keydata_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.fingerprint_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.timestamp_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.rawid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.currentindex_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.deviceindexes_),
+  0,
+  1,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_.keyid_),
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _impl_.keyids_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _impl_.keys_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keydata_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.seconds_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.ptt_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.streamingsidecar_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.waveform_),
+  0,
+  1,
+  2,
+  9,
+  10,
+  11,
+  3,
+  4,
+  5,
+  12,
+  8,
+  6,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_.displaytext_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.paramsjson_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttonid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttontext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.type_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.nativeflowinfo_),
+  0,
+  1,
+  3,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contenttext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.footertext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.buttons_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.headertype_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.header_),
+  0,
+  1,
+  2,
+  ~0u,
+  3,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.selectedbuttonid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.type_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.response_),
+  0,
+  1,
+  2,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.callkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversionsource_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondata_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondelayseconds_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_.key_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.displayname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.id_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.displayname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.vcard_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.contextinfo_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.displayname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contacts_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contextinfo_),
+  0,
+  ~0u,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_.key_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.destinationjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.phash_),
+  0,
+  2,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.pagecount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filename_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contactvcard_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnaildirectpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailheight_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailwidth_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.caption_),
+  0,
+  1,
+  2,
+  3,
+  14,
+  15,
+  4,
+  5,
+  6,
+  7,
+  17,
+  16,
+  8,
+  9,
+  10,
+  11,
+  13,
+  18,
+  19,
+  12,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.text_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.matchedtext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.canonicalurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.textargb_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.backgroundargb_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.font_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.previewtype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.donotplayinline_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnaildirectpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailheight_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailwidth_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupsubjectv2_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupthumbnailv2_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  13,
+  14,
+  15,
+  16,
+  5,
+  12,
+  17,
+  6,
+  7,
+  8,
+  9,
+  19,
+  18,
+  20,
+  21,
+  10,
+  11,
+  22,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_.message_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.invitecode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.inviteexpiration_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.caption_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.grouptype_),
+  0,
+  1,
+  6,
+  2,
+  3,
+  4,
+  5,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.currencycode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.amount1000_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofweek_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.month_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofmonth_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.hour_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.calendar_),
+  5,
+  0,
+  1,
+  2,
+  3,
+  4,
+  6,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_.timestamp_),
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_.datetimeOneof_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.default__),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.paramOneof_),
+  0,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.namespace__),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.elementname_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.params_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklg_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklc_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.localizableparams_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclg_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclc_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.hydratedhsm_),
+  0,
+  1,
+  ~0u,
+  2,
+  3,
+  ~0u,
+  4,
+  5,
+  6,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.synctype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.chunkorder_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.originalmessageid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.progress_),
+  0,
+  5,
+  1,
+  2,
+  3,
+  6,
+  7,
+  4,
+  8,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.caption_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.interactiveannotations_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscansidecar_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscanlength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.experimentgroupid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanssidecar_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanlengths_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfilesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.viewonce_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnaildirectpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.staticurl_),
+  0,
+  1,
+  2,
+  3,
+  17,
+  18,
+  19,
+  4,
+  5,
+  ~0u,
+  6,
+  20,
+  7,
+  16,
+  8,
+  21,
+  22,
+  9,
+  ~0u,
+  10,
+  11,
+  23,
+  12,
+  13,
+  14,
+  15,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_.securitynotificationenabled_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_.text_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.bizjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.messageversion_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_.text_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.subtitle_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.hasmediaattachment_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.media_),
+  0,
+  1,
+  2,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.buttonparamsjson_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.buttons_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageparamsjson_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageversion_),
+  ~0u,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.surface_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.messageversion_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.header_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.footer_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.contextinfo_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.interactiveMessage_),
+  0,
+  1,
+  2,
+  3,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_.text_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.paramsjson_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.version_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.contextinfo_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.interactiveResponseMessage_),
+  0,
+  1,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.note_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.token_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmenttype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfilesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentdirectpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentjpegthumbnail_),
+  0,
+  1,
+  9,
+  2,
+  3,
+  8,
+  4,
+  5,
+  6,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.keeptype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.timestampms_),
+  0,
+  2,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.productid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.jpegthumbnail_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.productsections_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.headerimage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.businessownerjid_),
+  ~0u,
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.products_),
+  0,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_.productid_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.rowid_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.rows_),
+  0,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.buttontext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.listtype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.sections_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.productlistinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.footertext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.contextinfo_),
+  0,
+  1,
+  2,
+  6,
+  ~0u,
+  4,
+  3,
+  5,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_.selectedrowid_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.listtype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.singleselectreply_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.description_),
+  0,
+  4,
+  2,
+  3,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslatitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslongitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.accuracyinmeters_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.speedinmps_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreesclockwisefrommagneticnorth_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.caption_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.sequencenumber_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.timeoffset_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.contextinfo_),
+  3,
+  4,
+  5,
+  6,
+  7,
+  0,
+  9,
+  8,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslatitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslongitude_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.address_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.islive_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.accuracyinmeters_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.speedinmps_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.comment_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.contextinfo_),
+  6,
+  7,
+  0,
+  1,
+  2,
+  8,
+  9,
+  10,
+  11,
+  3,
+  4,
+  5,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.orderid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.thumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.itemcount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.status_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.surface_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.ordertitle_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.sellerjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.token_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalamount1000_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalcurrencycode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.contextinfo_),
+  0,
+  1,
+  9,
+  10,
+  11,
+  2,
+  3,
+  4,
+  5,
+  8,
+  6,
+  7,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.servicetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.expirytimestamp_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_.optionname_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.enckey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.options_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.selectableoptionscount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.contextinfo_),
+  0,
+  1,
+  ~0u,
+  3,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.encpayload_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.enciv_),
+  0,
+  1,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessageMetadata, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.pollcreationmessagekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.vote_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.metadata_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.sendertimestampms_),
+  0,
+  1,
+  2,
+  3,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _impl_.selectedoptions_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.catalogimage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.description_),
+  2,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.currencycode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.priceamount1000_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.retailerid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.firstimageid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.salepriceamount1000_),
+  7,
+  0,
+  1,
+  2,
+  3,
+  8,
+  4,
+  5,
+  10,
+  6,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.product_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.businessownerjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.catalog_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.footer_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.contextinfo_),
+  3,
+  0,
+  4,
+  1,
+  2,
+  5,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.type_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralexpiration_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.historysyncnotification_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyshare_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyrequest_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.initialsecuritynotificationsettingsync_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatefatalexceptionnotification_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.disappearingmode_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadresponsemessage_),
+  0,
+  9,
+  10,
+  11,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.text_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.groupingkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.sendertimestampms_),
+  2,
+  0,
+  1,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.rmrsource_),
+  ~0u,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_),
+  0,
+  2,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.rmrsource_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.stanzaid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.reuploadresult_),
+  1,
+  0,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.notemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.currencycodeiso4217_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount1000_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.requestfrom_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.expirytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.background_),
+  2,
+  0,
+  5,
+  1,
+  6,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_.contextinfo_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.notemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.requestmessagekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.background_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.groupid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.axolotlsenderkeydistributionmessage_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframesidecar_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.isanimated_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.pngthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.contextinfo_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  9,
+  10,
+  5,
+  11,
+  12,
+  13,
+  6,
+  14,
+  7,
+  8,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.filehash_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.rmrsource_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.requesttimestamp_),
+  ~0u,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedid_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selecteddisplaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedindex_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.content_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.footer_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.buttons_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.title_),
+  0,
+  1,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedcontenttext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedfootertext_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedbuttons_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.templateid_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.title_),
+  0,
+  1,
+  ~0u,
+  2,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.hydratedtemplate_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.format_),
+  0,
+  1,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.seconds_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.caption_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifplayback_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.interactiveannotations_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.jpegthumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.contextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.streamingsidecar_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifattribution_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.viewonce_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnaildirectpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.staticurl_),
+  0,
+  1,
+  2,
+  14,
+  15,
+  3,
+  4,
+  18,
+  16,
+  17,
+  5,
+  ~0u,
+  6,
+  20,
+  7,
+  13,
+  8,
+  21,
+  19,
+  9,
+  10,
+  11,
+  12,
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.conversation_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.senderkeydistributionmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.imagemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.locationmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.extendedtextmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.audiomessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.videomessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.call_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.chat_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.protocolmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactsarraymessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.highlystructuredmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.fastratchetkeysenderkeydistributionmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.sendpaymentmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.livelocationmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestpaymentmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.declinepaymentrequestmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.cancelpaymentrequestmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickermessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.groupinvitemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatebuttonreplymessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.productmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.devicesentmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.messagecontextinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ordermessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listresponsemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ephemeralmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.invoicemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsresponsemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.paymentinvitemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactivemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.reactionmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickersyncrmrmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactiveresponsemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollcreationmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollupdatemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.keepinchatmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentwithcaptionmessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestphonenumbermessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessagev2_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadata_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadataversion_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.messagesecret_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.paddingbytes_),
+  2,
+  3,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.remotejid_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.fromme_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.participant_),
+  0,
+  3,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Money, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.value_),
+  PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.offset_),
+  PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.currencycode_),
+  1,
+  2,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_.name_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.caption_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lng_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.islive_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lat_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentamount1000_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentnotemsgbody_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.canonicalurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.matchedtext_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.title_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.description_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.futureproofbuffer_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.clienturl_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.loc_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollname_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.polloptions_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollselectableoptionscount_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.messagesecret_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.sendertimestampms_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollupdateparentkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.encpollvote_),
+  0,
+  1,
+  14,
+  16,
+  15,
+  17,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  ~0u,
+  19,
+  11,
+  18,
+  12,
+  13,
+  PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.currentmsg_),
+  PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.quotedmsg_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.serial_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.issuer_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.expires_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.subject_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.key_),
+  4,
+  0,
+  3,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.signature_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.messagetimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.participant_),
+  1,
+  2,
+  3,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.userjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavereason_),
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavets_),
+  0,
+  2,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.groupjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.pastparticipants_),
+  0,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakeytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.directpath_),
+  0,
+  4,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.placeholderargb_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.textargb_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.subtextargb_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mediadata_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.type_),
+  0,
+  3,
+  4,
+  5,
+  1,
+  6,
+  7,
+  8,
+  2,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currencydeprecated_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.amount1000_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.receiverjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.status_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.transactiontimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.requestmessagekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.expirytimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.futureproofed_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currency_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.txnstatus_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.usenovifiatformat_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.primaryamount_),
+  PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.exchangeamount_),
+  6,
+  5,
+  0,
+  7,
+  8,
+  2,
+  9,
+  10,
+  1,
+  12,
+  11,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.sequence_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekeyprivate_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkeyprivate_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykeyprivate_),
+  6,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.prekeyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.signedprekeyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.basekey_),
+  1,
+  2,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.oldphoto_),
+  PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphoto_),
+  PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphotoid_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.xdeprecated_),
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.ydeprecated_),
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.x_),
+  PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.y_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_.pollinvalidated_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.encpayload_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.enciv_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.pollupdatemessagekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.vote_),
+  PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.sendertimestampms_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.publickey_),
+  PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.privatekey_),
+  2,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Pushname, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.pushname_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.text_),
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.groupingkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.sendertimestampms_),
+  PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.unread_),
+  2,
+  0,
+  1,
+  3,
+  4,
+  PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.emoji_),
+  PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.weight_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.currentsession_),
+  PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.previoussessions_),
+  0,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.iteration_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.seed_),
+  1,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _impl_.senderkeystates_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderkeyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderchainkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendersigningkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendermessagekeys_),
+  2,
+  0,
+  1,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.iteration_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.seed_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.public__),
+  PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.private__),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_.stanzaid_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.sessionversion_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localidentitypublic_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteidentitypublic_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.rootkey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.previouscounter_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.senderchain_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.receiverchains_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingkeyexchange_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingprekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteregistrationid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localregistrationid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.needsrefresh_),
+  PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.alicebasekey_),
+  7,
+  0,
+  1,
+  2,
+  8,
+  4,
+  ~0u,
+  5,
+  6,
+  9,
+  10,
+  11,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.id_),
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.publickey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.privatekey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.signature_),
+  PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.timestamp_),
+  4,
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignid_),
+  PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignexpirationtimestamp_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filesha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.weight_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  6,
+  7,
+  5,
+  8,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.index_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.value_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.padding_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.version_),
+  0,
+  2,
+  1,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.deviceid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.isdeleted_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_.allowed_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.archived_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.messagerange_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_.messagerange_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.fullname_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.firstname_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_.messagerange_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_.expiredkeyepoch_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_.labeled_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.color_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.predefinedid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.deleted_),
+  0,
+  1,
+  2,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_.locale_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.read_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muted_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muteendtimestamp_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_.acknowledged_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_.pinned_),
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _impl_.flags_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_.version_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_.name_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.shortcut_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.keywords_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.count_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.deleted_),
+  0,
+  1,
+  ~0u,
+  2,
+  3,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _impl_.weights_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_.shownotification_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_.starred_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.url_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.fileencsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mediakey_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mimetype_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.height_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.width_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.directpath_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.filelength_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.isfavorite_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.deviceidhint_),
+  0,
+  1,
+  2,
+  3,
+  5,
+  6,
+  4,
+  7,
+  8,
+  9,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isdeactivated_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isautorenewing_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.expirationdate_),
+  1,
+  2,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.messages_),
+  0,
+  1,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.timestamp_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_.istwentyfourhourformatenabled_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_.unarchivechats_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_.muted_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.staraction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.contactaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.muteaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pinaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.securitynotificationsetting_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pushnamesetting_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.quickreplyaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.recentemojiweightsaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labeleditaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labelassociationaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.localesetting_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.archivechataction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletemessageformeaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.keyexpiration_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.markchatasreadaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.clearchataction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletechataction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.unarchivechatssetting_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryfeature_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.androidunsupportedactions_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.agentaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.subscriptionaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.userstatusmuteaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timeformataction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.nuxaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryversionaction_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.stickeraction_),
+  27,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_.blob_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.operation_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.record_),
+  1,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _impl_.mutations_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.mutations_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.externalmutations_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.snapshotmac_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.patchmac_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.keyid_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.exitcode_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.deviceindex_),
+  2,
+  ~0u,
+  3,
+  0,
+  1,
+  4,
+  5,
+  6,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.index_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.value_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.keyid_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.records_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.mac_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.keyid_),
+  1,
+  ~0u,
+  0,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_.blob_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_.version_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.phonenumber_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.id_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.displaytext_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.url_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.index_),
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.button_),
+  0,
+  ~0u,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.userjid_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.receipttimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.readtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.playedtimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.pendingdevicejid_),
+  PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.delivereddevicejid_),
+  0,
+  1,
+  2,
+  3,
+  ~0u,
+  ~0u,
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.serial_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuer_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.verifiedname_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.localizednames_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuetime_),
+  2,
+  0,
+  1,
+  ~0u,
+  3,
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.details_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.signature_),
+  PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.serversignature_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.filename_),
+  PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.opacity_),
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsdisplay_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualoutgoing_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3create_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.changenumberv2_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.querystatusv3thumbnail_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocations_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.queryvname_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualincoming_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.quickrepliesquery_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.payments_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.stickerpackquery_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocationsfinal_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsedit_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediaupload_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediauploadrichquickreplies_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.vnamev2_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.videoplaybackurl_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.statusranking_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualvideo_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.thirdpartystickers_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.frequentlyforwardedsetting_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv4joinpermission_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickers_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.catalog_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.starredstickers_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipgroupcall_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessage_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessageinteractivity_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralmessages_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.e2enotificationsync_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv2_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv3_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.usernotice_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.support_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupuiicleanup_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupdogfoodinginternalonly_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.settingssync_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.archivev2_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralallowgroupmembers_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeral24hduration_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mdforceupgrade_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.disappearingmode_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.externalmdoptinavailable_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.nodeletemessagetimelimit_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.key_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.message_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagetimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.status_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.participant_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagec2stimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ignore_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.starred_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.broadcast_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pushname_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediaciphertextsha256_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.multicast_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urltext_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urlnumber_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubtype_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.clearmedia_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubparameters_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.duration_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.labels_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.paymentinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.finallivelocation_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedpaymentinfo_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralstarttimestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralduration_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralofftoon_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeraloutofsync_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.bizprivacystatus_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.verifiedbizname_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediadata_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.photochange_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.userreceipt_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.reactions_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedstickerdata_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.futureproofdata_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statuspsa_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pollupdates_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.polladditionalmetadata_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.agentid_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statusalreadyviewed_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagesecret_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.keepinchat_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.originalselfauthoruserjidstring_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.revokemessagetimestamp_),
+  8,
+  9,
+  19,
+  21,
+  0,
+  20,
+  22,
+  23,
+  24,
+  1,
+  2,
+  25,
+  27,
+  28,
+  26,
+  29,
+  ~0u,
+  31,
+  ~0u,
+  10,
+  11,
+  12,
+  33,
+  32,
+  30,
+  35,
+  34,
+  3,
+  13,
+  14,
+  ~0u,
+  ~0u,
+  15,
+  4,
+  16,
+  ~0u,
+  17,
+  5,
+  36,
+  6,
+  18,
+  7,
+  37,
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.timestamp_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.unreadchats_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessagecount_),
+  PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessages_),
+  0,
+  1,
+  2,
+  ~0u,
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 9, -1, sizeof(::proto::ADVDeviceIdentity)},
+  { 12, 22, -1, sizeof(::proto::ADVKeyIndexList)},
+  { 26, 36, -1, sizeof(::proto::ADVSignedDeviceIdentity)},
+  { 40, 48, -1, sizeof(::proto::ADVSignedDeviceIdentityHMAC)},
+  { 50, 58, -1, sizeof(::proto::ADVSignedKeyIndexList)},
+  { 60, 68, -1, sizeof(::proto::ActionLink)},
+  { 70, 80, -1, sizeof(::proto::AutoDownloadSettings)},
+  { 84, 95, -1, sizeof(::proto::BizAccountLinkInfo)},
+  { 100, 108, -1, sizeof(::proto::BizAccountPayload)},
+  { 110, 124, -1, sizeof(::proto::BizIdentityInfo)},
+  { 132, 143, -1, sizeof(::proto::CertChain_NoiseCertificate_Details)},
+  { 148, 156, -1, sizeof(::proto::CertChain_NoiseCertificate)},
+  { 158, 166, -1, sizeof(::proto::CertChain)},
+  { 168, 178, -1, sizeof(::proto::Chain)},
+  { 182, 190, -1, sizeof(::proto::ChainKey)},
+  { 192, 200, -1, sizeof(::proto::ClientPayload_DNSSource)},
+  { 202, 216, -1, sizeof(::proto::ClientPayload_DevicePairingRegistrationData)},
+  { 224, 235, -1, sizeof(::proto::ClientPayload_UserAgent_AppVersion)},
+  { 240, 259, -1, sizeof(::proto::ClientPayload_UserAgent)},
+  { 272, 289, -1, sizeof(::proto::ClientPayload_WebInfo_WebdPayload)},
+  { 300, 310, -1, sizeof(::proto::ClientPayload_WebInfo)},
+  { 314, 344, -1, sizeof(::proto::ClientPayload)},
+  { 368, 378, -1, sizeof(::proto::ContextInfo_AdReplyInfo)},
+  { 382, 400, -1, sizeof(::proto::ContextInfo_ExternalAdReplyInfo)},
+  { 412, 441, -1, sizeof(::proto::ContextInfo)},
+  { 464, 510, -1, sizeof(::proto::Conversation)},
+  { 550, 562, -1, sizeof(::proto::DeviceListMetadata)},
+  { 568, 579, -1, sizeof(::proto::DeviceProps_AppVersion)},
+  { 584, 594, -1, sizeof(::proto::DeviceProps)},
+  { 598, 605, -1, sizeof(::proto::DisappearingMode)},
+  { 606, 614, -1, sizeof(::proto::EphemeralSetting)},
+  { 616, 624, -1, sizeof(::proto::ExitCode)},
+  { 626, 638, -1, sizeof(::proto::ExternalBlobReference)},
+  { 644, 660, -1, sizeof(::proto::GlobalSettings)},
+  { 670, 678, -1, sizeof(::proto::GroupParticipant)},
+  { 680, 688, -1, sizeof(::proto::HandshakeMessage_ClientFinish)},
+  { 690, 699, -1, sizeof(::proto::HandshakeMessage_ClientHello)},
+  { 702, 711, -1, sizeof(::proto::HandshakeMessage_ServerHello)},
+  { 714, 723, -1, sizeof(::proto::HandshakeMessage)},
+  { 726, 743, -1, sizeof(::proto::HistorySync)},
+  { 754, 762, -1, sizeof(::proto::HistorySyncMsg)},
+  { 764, 772, -1, sizeof(::proto::HydratedTemplateButton_HydratedCallButton)},
+  { 774, 782, -1, sizeof(::proto::HydratedTemplateButton_HydratedQuickReplyButton)},
+  { 784, 792, -1, sizeof(::proto::HydratedTemplateButton_HydratedURLButton)},
+  { 794, 805, -1, sizeof(::proto::HydratedTemplateButton)},
+  { 809, 817, -1, sizeof(::proto::IdentityKeyPairStructure)},
+  { 819, -1, -1, sizeof(::proto::InteractiveAnnotation)},
+  { 828, 838, -1, sizeof(::proto::KeepInChat)},
+  { 842, 849, -1, sizeof(::proto::KeyId)},
+  { 850, 859, -1, sizeof(::proto::LocalizedName)},
+  { 862, 871, -1, sizeof(::proto::Location)},
+  { 874, 881, -1, sizeof(::proto::MediaData)},
+  { 882, 891, -1, sizeof(::proto::MediaRetryNotification)},
+  { 894, 902, -1, sizeof(::proto::Message_AppStateFatalExceptionNotification)},
+  { 904, 913, -1, sizeof(::proto::Message_AppStateSyncKeyData)},
+  { 916, 925, -1, sizeof(::proto::Message_AppStateSyncKeyFingerprint)},
+  { 928, 935, -1, sizeof(::proto::Message_AppStateSyncKeyId)},
+  { 936, -1, -1, sizeof(::proto::Message_AppStateSyncKeyRequest)},
+  { 943, -1, -1, sizeof(::proto::Message_AppStateSyncKeyShare)},
+  { 950, 958, -1, sizeof(::proto::Message_AppStateSyncKey)},
+  { 960, 979, -1, sizeof(::proto::Message_AudioMessage)},
+  { 992, 999, -1, sizeof(::proto::Message_ButtonsMessage_Button_ButtonText)},
+  { 1000, 1008, -1, sizeof(::proto::Message_ButtonsMessage_Button_NativeFlowInfo)},
+  { 1010, 1020, -1, sizeof(::proto::Message_ButtonsMessage_Button)},
+  { 1024, 1041, -1, sizeof(::proto::Message_ButtonsMessage)},
+  { 1051, 1062, -1, sizeof(::proto::Message_ButtonsResponseMessage)},
+  { 1066, 1076, -1, sizeof(::proto::Message_Call)},
+  { 1080, 1087, -1, sizeof(::proto::Message_CancelPaymentRequestMessage)},
+  { 1088, 1096, -1, sizeof(::proto::Message_Chat)},
+  { 1098, 1107, -1, sizeof(::proto::Message_ContactMessage)},
+  { 1110, 1119, -1, sizeof(::proto::Message_ContactsArrayMessage)},
+  { 1122, 1129, -1, sizeof(::proto::Message_DeclinePaymentRequestMessage)},
+  { 1130, 1139, -1, sizeof(::proto::Message_DeviceSentMessage)},
+  { 1142, 1168, -1, sizeof(::proto::Message_DocumentMessage)},
+  { 1188, 1217, -1, sizeof(::proto::Message_ExtendedTextMessage)},
+  { 1240, 1247, -1, sizeof(::proto::Message_FutureProofMessage)},
+  { 1248, 1262, -1, sizeof(::proto::Message_GroupInviteMessage)},
+  { 1270, 1278, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency)},
+  { 1280, 1293, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent)},
+  { 1300, 1307, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch)},
+  { 1308, -1, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime)},
+  { 1317, 1327, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter)},
+  { 1330, 1345, -1, sizeof(::proto::Message_HighlyStructuredMessage)},
+  { 1354, 1369, -1, sizeof(::proto::Message_HistorySyncNotification)},
+  { 1378, 1410, -1, sizeof(::proto::Message_ImageMessage)},
+  { 1436, 1443, -1, sizeof(::proto::Message_InitialSecurityNotificationSettingSync)},
+  { 1444, 1451, -1, sizeof(::proto::Message_InteractiveMessage_Body)},
+  { 1452, 1461, -1, sizeof(::proto::Message_InteractiveMessage_CollectionMessage)},
+  { 1464, 1471, -1, sizeof(::proto::Message_InteractiveMessage_Footer)},
+  { 1472, 1486, -1, sizeof(::proto::Message_InteractiveMessage_Header)},
+  { 1493, 1501, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton)},
+  { 1503, 1512, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage)},
+  { 1515, 1524, -1, sizeof(::proto::Message_InteractiveMessage_ShopMessage)},
+  { 1527, 1541, -1, sizeof(::proto::Message_InteractiveMessage)},
+  { 1548, 1555, -1, sizeof(::proto::Message_InteractiveResponseMessage_Body)},
+  { 1556, 1565, -1, sizeof(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage)},
+  { 1568, 1578, -1, sizeof(::proto::Message_InteractiveResponseMessage)},
+  { 1581, 1597, -1, sizeof(::proto::Message_InvoiceMessage)},
+  { 1607, 1616, -1, sizeof(::proto::Message_KeepInChatMessage)},
+  { 1619, 1627, -1, sizeof(::proto::Message_ListMessage_ProductListHeaderImage)},
+  { 1629, 1638, -1, sizeof(::proto::Message_ListMessage_ProductListInfo)},
+  { 1641, 1649, -1, sizeof(::proto::Message_ListMessage_ProductSection)},
+  { 1651, 1658, -1, sizeof(::proto::Message_ListMessage_Product)},
+  { 1659, 1668, -1, sizeof(::proto::Message_ListMessage_Row)},
+  { 1671, 1679, -1, sizeof(::proto::Message_ListMessage_Section)},
+  { 1681, 1695, -1, sizeof(::proto::Message_ListMessage)},
+  { 1703, 1710, -1, sizeof(::proto::Message_ListResponseMessage_SingleSelectReply)},
+  { 1711, 1722, -1, sizeof(::proto::Message_ListResponseMessage)},
+  { 1727, 1743, -1, sizeof(::proto::Message_LiveLocationMessage)},
+  { 1753, 1771, -1, sizeof(::proto::Message_LocationMessage)},
+  { 1783, 1801, -1, sizeof(::proto::Message_OrderMessage)},
+  { 1813, 1821, -1, sizeof(::proto::Message_PaymentInviteMessage)},
+  { 1823, 1830, -1, sizeof(::proto::Message_PollCreationMessage_Option)},
+  { 1831, 1842, -1, sizeof(::proto::Message_PollCreationMessage)},
+  { 1847, 1855, -1, sizeof(::proto::Message_PollEncValue)},
+  { 1857, -1, -1, sizeof(::proto::Message_PollUpdateMessageMetadata)},
+  { 1863, 1873, -1, sizeof(::proto::Message_PollUpdateMessage)},
+  { 1877, -1, -1, sizeof(::proto::Message_PollVoteMessage)},
+  { 1884, 1893, -1, sizeof(::proto::Message_ProductMessage_CatalogSnapshot)},
+  { 1896, 1913, -1, sizeof(::proto::Message_ProductMessage_ProductSnapshot)},
+  { 1924, 1936, -1, sizeof(::proto::Message_ProductMessage)},
+  { 1942, 1960, -1, sizeof(::proto::Message_ProtocolMessage)},
+  { 1972, 1982, -1, sizeof(::proto::Message_ReactionMessage)},
+  { 1986, 1994, -1, sizeof(::proto::Message_RequestMediaUploadMessage)},
+  { 1996, 2005, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult)},
+  { 2008, 2017, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage)},
+  { 2020, 2033, -1, sizeof(::proto::Message_RequestPaymentMessage)},
+  { 2040, 2047, -1, sizeof(::proto::Message_RequestPhoneNumberMessage)},
+  { 2048, 2057, -1, sizeof(::proto::Message_SendPaymentMessage)},
+  { 2060, 2068, -1, sizeof(::proto::Message_SenderKeyDistributionMessage)},
+  { 2070, 2091, -1, sizeof(::proto::Message_StickerMessage)},
+  { 2106, 2115, -1, sizeof(::proto::Message_StickerSyncRMRMessage)},
+  { 2118, 2128, -1, sizeof(::proto::Message_TemplateButtonReplyMessage)},
+  { 2132, 2147, -1, sizeof(::proto::Message_TemplateMessage_FourRowTemplate)},
+  { 2155, 2171, -1, sizeof(::proto::Message_TemplateMessage_HydratedFourRowTemplate)},
+  { 2180, 2191, -1, sizeof(::proto::Message_TemplateMessage)},
+  { 2195, 2224, -1, sizeof(::proto::Message_VideoMessage)},
+  { 2247, 2299, -1, sizeof(::proto::Message)},
+  { 2345, 2355, -1, sizeof(::proto::MessageContextInfo)},
+  { 2359, 2369, -1, sizeof(::proto::MessageKey)},
+  { 2373, 2382, -1, sizeof(::proto::Money)},
+  { 2385, 2392, -1, sizeof(::proto::MsgOpaqueData_PollOption)},
+  { 2393, 2420, -1, sizeof(::proto::MsgOpaqueData)},
+  { 2441, 2449, -1, sizeof(::proto::MsgRowOpaqueData)},
+  { 2451, 2462, -1, sizeof(::proto::NoiseCertificate_Details)},
+  { 2467, 2475, -1, sizeof(::proto::NoiseCertificate)},
+  { 2477, 2487, -1, sizeof(::proto::NotificationMessageInfo)},
+  { 2491, 2500, -1, sizeof(::proto::PastParticipant)},
+  { 2503, 2511, -1, sizeof(::proto::PastParticipants)},
+  { 2513, 2524, -1, sizeof(::proto::PaymentBackground_MediaData)},
+  { 2529, 2545, -1, sizeof(::proto::PaymentBackground)},
+  { 2555, 2574, -1, sizeof(::proto::PaymentInfo)},
+  { 2587, 2600, -1, sizeof(::proto::PendingKeyExchange)},
+  { 2607, 2616, -1, sizeof(::proto::PendingPreKey)},
+  { 2619, 2628, -1, sizeof(::proto::PhotoChange)},
+  { 2631, 2641, -1, sizeof(::proto::Point)},
+  { 2645, 2652, -1, sizeof(::proto::PollAdditionalMetadata)},
+  { 2653, 2661, -1, sizeof(::proto::PollEncValue)},
+  { 2663, 2672, -1, sizeof(::proto::PollUpdate)},
+  { 2675, 2684, -1, sizeof(::proto::PreKeyRecordStructure)},
+  { 2687, 2695, -1, sizeof(::proto::Pushname)},
+  { 2697, 2708, -1, sizeof(::proto::Reaction)},
+  { 2713, 2721, -1, sizeof(::proto::RecentEmojiWeight)},
+  { 2723, 2731, -1, sizeof(::proto::RecordStructure)},
+  { 2733, 2741, -1, sizeof(::proto::SenderChainKey)},
+  { 2743, -1, -1, sizeof(::proto::SenderKeyRecordStructure)},
+  { 2750, 2760, -1, sizeof(::proto::SenderKeyStateStructure)},
+  { 2764, 2772, -1, sizeof(::proto::SenderMessageKey)},
+  { 2774, 2782, -1, sizeof(::proto::SenderSigningKey)},
+  { 2784, 2791, -1, sizeof(::proto::ServerErrorReceipt)},
+  { 2792, 2811, -1, sizeof(::proto::SessionStructure)},
+  { 2824, 2835, -1, sizeof(::proto::SignedPreKeyRecordStructure)},
+  { 2840, 2848, -1, sizeof(::proto::StatusPSA)},
+  { 2850, 2866, -1, sizeof(::proto::StickerMetadata)},
+  { 2876, 2886, -1, sizeof(::proto::SyncActionData)},
+  { 2890, 2899, -1, sizeof(::proto::SyncActionValue_AgentAction)},
+  { 2902, 2909, -1, sizeof(::proto::SyncActionValue_AndroidUnsupportedActions)},
+  { 2910, 2918, -1, sizeof(::proto::SyncActionValue_ArchiveChatAction)},
+  { 2920, 2927, -1, sizeof(::proto::SyncActionValue_ClearChatAction)},
+  { 2928, 2936, -1, sizeof(::proto::SyncActionValue_ContactAction)},
+  { 2938, 2945, -1, sizeof(::proto::SyncActionValue_DeleteChatAction)},
+  { 2946, 2954, -1, sizeof(::proto::SyncActionValue_DeleteMessageForMeAction)},
+  { 2956, 2963, -1, sizeof(::proto::SyncActionValue_KeyExpiration)},
+  { 2964, 2971, -1, sizeof(::proto::SyncActionValue_LabelAssociationAction)},
+  { 2972, 2982, -1, sizeof(::proto::SyncActionValue_LabelEditAction)},
+  { 2986, 2993, -1, sizeof(::proto::SyncActionValue_LocaleSetting)},
+  { 2994, 3002, -1, sizeof(::proto::SyncActionValue_MarkChatAsReadAction)},
+  { 3004, 3012, -1, sizeof(::proto::SyncActionValue_MuteAction)},
+  { 3014, 3021, -1, sizeof(::proto::SyncActionValue_NuxAction)},
+  { 3022, 3029, -1, sizeof(::proto::SyncActionValue_PinAction)},
+  { 3030, -1, -1, sizeof(::proto::SyncActionValue_PrimaryFeature)},
+  { 3037, 3044, -1, sizeof(::proto::SyncActionValue_PrimaryVersionAction)},
+  { 3045, 3052, -1, sizeof(::proto::SyncActionValue_PushNameSetting)},
+  { 3053, 3064, -1, sizeof(::proto::SyncActionValue_QuickReplyAction)},
+  { 3069, -1, -1, sizeof(::proto::SyncActionValue_RecentEmojiWeightsAction)},
+  { 3076, 3083, -1, sizeof(::proto::SyncActionValue_SecurityNotificationSetting)},
+  { 3084, 3091, -1, sizeof(::proto::SyncActionValue_StarAction)},
+  { 3092, 3108, -1, sizeof(::proto::SyncActionValue_StickerAction)},
+  { 3118, 3127, -1, sizeof(::proto::SyncActionValue_SubscriptionAction)},
+  { 3130, 3139, -1, sizeof(::proto::SyncActionValue_SyncActionMessageRange)},
+  { 3142, 3150, -1, sizeof(::proto::SyncActionValue_SyncActionMessage)},
+  { 3152, 3159, -1, sizeof(::proto::SyncActionValue_TimeFormatAction)},
+  { 3160, 3167, -1, sizeof(::proto::SyncActionValue_UnarchiveChatsSetting)},
+  { 3168, 3175, -1, sizeof(::proto::SyncActionValue_UserStatusMuteAction)},
+  { 3176, 3210, -1, sizeof(::proto::SyncActionValue)},
+  { 3238, 3245, -1, sizeof(::proto::SyncdIndex)},
+  { 3246, 3254, -1, sizeof(::proto::SyncdMutation)},
+  { 3256, -1, -1, sizeof(::proto::SyncdMutations)},
+  { 3263, 3277, -1, sizeof(::proto::SyncdPatch)},
+  { 3285, 3294, -1, sizeof(::proto::SyncdRecord)},
+  { 3297, 3307, -1, sizeof(::proto::SyncdSnapshot)},
+  { 3311, 3318, -1, sizeof(::proto::SyncdValue)},
+  { 3319, 3326, -1, sizeof(::proto::SyncdVersion)},
+  { 3327, 3335, -1, sizeof(::proto::TemplateButton_CallButton)},
+  { 3337, 3345, -1, sizeof(::proto::TemplateButton_QuickReplyButton)},
+  { 3347, 3355, -1, sizeof(::proto::TemplateButton_URLButton)},
+  { 3357, 3368, -1, sizeof(::proto::TemplateButton)},
+  { 3372, 3384, -1, sizeof(::proto::UserReceipt)},
+  { 3390, 3401, -1, sizeof(::proto::VerifiedNameCertificate_Details)},
+  { 3406, 3415, -1, sizeof(::proto::VerifiedNameCertificate)},
+  { 3418, 3426, -1, sizeof(::proto::WallpaperSettings)},
+  { 3428, 3479, -1, sizeof(::proto::WebFeatures)},
+  { 3524, 3573, -1, sizeof(::proto::WebMessageInfo)},
+  { 3616, 3626, -1, sizeof(::proto::WebNotificationsInfo)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::proto::_ADVDeviceIdentity_default_instance_._instance,
+  &::proto::_ADVKeyIndexList_default_instance_._instance,
+  &::proto::_ADVSignedDeviceIdentity_default_instance_._instance,
+  &::proto::_ADVSignedDeviceIdentityHMAC_default_instance_._instance,
+  &::proto::_ADVSignedKeyIndexList_default_instance_._instance,
+  &::proto::_ActionLink_default_instance_._instance,
+  &::proto::_AutoDownloadSettings_default_instance_._instance,
+  &::proto::_BizAccountLinkInfo_default_instance_._instance,
+  &::proto::_BizAccountPayload_default_instance_._instance,
+  &::proto::_BizIdentityInfo_default_instance_._instance,
+  &::proto::_CertChain_NoiseCertificate_Details_default_instance_._instance,
+  &::proto::_CertChain_NoiseCertificate_default_instance_._instance,
+  &::proto::_CertChain_default_instance_._instance,
+  &::proto::_Chain_default_instance_._instance,
+  &::proto::_ChainKey_default_instance_._instance,
+  &::proto::_ClientPayload_DNSSource_default_instance_._instance,
+  &::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_._instance,
+  &::proto::_ClientPayload_UserAgent_AppVersion_default_instance_._instance,
+  &::proto::_ClientPayload_UserAgent_default_instance_._instance,
+  &::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_._instance,
+  &::proto::_ClientPayload_WebInfo_default_instance_._instance,
+  &::proto::_ClientPayload_default_instance_._instance,
+  &::proto::_ContextInfo_AdReplyInfo_default_instance_._instance,
+  &::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_._instance,
+  &::proto::_ContextInfo_default_instance_._instance,
+  &::proto::_Conversation_default_instance_._instance,
+  &::proto::_DeviceListMetadata_default_instance_._instance,
+  &::proto::_DeviceProps_AppVersion_default_instance_._instance,
+  &::proto::_DeviceProps_default_instance_._instance,
+  &::proto::_DisappearingMode_default_instance_._instance,
+  &::proto::_EphemeralSetting_default_instance_._instance,
+  &::proto::_ExitCode_default_instance_._instance,
+  &::proto::_ExternalBlobReference_default_instance_._instance,
+  &::proto::_GlobalSettings_default_instance_._instance,
+  &::proto::_GroupParticipant_default_instance_._instance,
+  &::proto::_HandshakeMessage_ClientFinish_default_instance_._instance,
+  &::proto::_HandshakeMessage_ClientHello_default_instance_._instance,
+  &::proto::_HandshakeMessage_ServerHello_default_instance_._instance,
+  &::proto::_HandshakeMessage_default_instance_._instance,
+  &::proto::_HistorySync_default_instance_._instance,
+  &::proto::_HistorySyncMsg_default_instance_._instance,
+  &::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_._instance,
+  &::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_._instance,
+  &::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_._instance,
+  &::proto::_HydratedTemplateButton_default_instance_._instance,
+  &::proto::_IdentityKeyPairStructure_default_instance_._instance,
+  &::proto::_InteractiveAnnotation_default_instance_._instance,
+  &::proto::_KeepInChat_default_instance_._instance,
+  &::proto::_KeyId_default_instance_._instance,
+  &::proto::_LocalizedName_default_instance_._instance,
+  &::proto::_Location_default_instance_._instance,
+  &::proto::_MediaData_default_instance_._instance,
+  &::proto::_MediaRetryNotification_default_instance_._instance,
+  &::proto::_Message_AppStateFatalExceptionNotification_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKeyData_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKeyFingerprint_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKeyId_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKeyRequest_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKeyShare_default_instance_._instance,
+  &::proto::_Message_AppStateSyncKey_default_instance_._instance,
+  &::proto::_Message_AudioMessage_default_instance_._instance,
+  &::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_._instance,
+  &::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_._instance,
+  &::proto::_Message_ButtonsMessage_Button_default_instance_._instance,
+  &::proto::_Message_ButtonsMessage_default_instance_._instance,
+  &::proto::_Message_ButtonsResponseMessage_default_instance_._instance,
+  &::proto::_Message_Call_default_instance_._instance,
+  &::proto::_Message_CancelPaymentRequestMessage_default_instance_._instance,
+  &::proto::_Message_Chat_default_instance_._instance,
+  &::proto::_Message_ContactMessage_default_instance_._instance,
+  &::proto::_Message_ContactsArrayMessage_default_instance_._instance,
+  &::proto::_Message_DeclinePaymentRequestMessage_default_instance_._instance,
+  &::proto::_Message_DeviceSentMessage_default_instance_._instance,
+  &::proto::_Message_DocumentMessage_default_instance_._instance,
+  &::proto::_Message_ExtendedTextMessage_default_instance_._instance,
+  &::proto::_Message_FutureProofMessage_default_instance_._instance,
+  &::proto::_Message_GroupInviteMessage_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_._instance,
+  &::proto::_Message_HighlyStructuredMessage_default_instance_._instance,
+  &::proto::_Message_HistorySyncNotification_default_instance_._instance,
+  &::proto::_Message_ImageMessage_default_instance_._instance,
+  &::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_Body_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_Footer_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_Header_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_ShopMessage_default_instance_._instance,
+  &::proto::_Message_InteractiveMessage_default_instance_._instance,
+  &::proto::_Message_InteractiveResponseMessage_Body_default_instance_._instance,
+  &::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_._instance,
+  &::proto::_Message_InteractiveResponseMessage_default_instance_._instance,
+  &::proto::_Message_InvoiceMessage_default_instance_._instance,
+  &::proto::_Message_KeepInChatMessage_default_instance_._instance,
+  &::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_._instance,
+  &::proto::_Message_ListMessage_ProductListInfo_default_instance_._instance,
+  &::proto::_Message_ListMessage_ProductSection_default_instance_._instance,
+  &::proto::_Message_ListMessage_Product_default_instance_._instance,
+  &::proto::_Message_ListMessage_Row_default_instance_._instance,
+  &::proto::_Message_ListMessage_Section_default_instance_._instance,
+  &::proto::_Message_ListMessage_default_instance_._instance,
+  &::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_._instance,
+  &::proto::_Message_ListResponseMessage_default_instance_._instance,
+  &::proto::_Message_LiveLocationMessage_default_instance_._instance,
+  &::proto::_Message_LocationMessage_default_instance_._instance,
+  &::proto::_Message_OrderMessage_default_instance_._instance,
+  &::proto::_Message_PaymentInviteMessage_default_instance_._instance,
+  &::proto::_Message_PollCreationMessage_Option_default_instance_._instance,
+  &::proto::_Message_PollCreationMessage_default_instance_._instance,
+  &::proto::_Message_PollEncValue_default_instance_._instance,
+  &::proto::_Message_PollUpdateMessageMetadata_default_instance_._instance,
+  &::proto::_Message_PollUpdateMessage_default_instance_._instance,
+  &::proto::_Message_PollVoteMessage_default_instance_._instance,
+  &::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_._instance,
+  &::proto::_Message_ProductMessage_ProductSnapshot_default_instance_._instance,
+  &::proto::_Message_ProductMessage_default_instance_._instance,
+  &::proto::_Message_ProtocolMessage_default_instance_._instance,
+  &::proto::_Message_ReactionMessage_default_instance_._instance,
+  &::proto::_Message_RequestMediaUploadMessage_default_instance_._instance,
+  &::proto::_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_._instance,
+  &::proto::_Message_RequestMediaUploadResponseMessage_default_instance_._instance,
+  &::proto::_Message_RequestPaymentMessage_default_instance_._instance,
+  &::proto::_Message_RequestPhoneNumberMessage_default_instance_._instance,
+  &::proto::_Message_SendPaymentMessage_default_instance_._instance,
+  &::proto::_Message_SenderKeyDistributionMessage_default_instance_._instance,
+  &::proto::_Message_StickerMessage_default_instance_._instance,
+  &::proto::_Message_StickerSyncRMRMessage_default_instance_._instance,
+  &::proto::_Message_TemplateButtonReplyMessage_default_instance_._instance,
+  &::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_._instance,
+  &::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_._instance,
+  &::proto::_Message_TemplateMessage_default_instance_._instance,
+  &::proto::_Message_VideoMessage_default_instance_._instance,
+  &::proto::_Message_default_instance_._instance,
+  &::proto::_MessageContextInfo_default_instance_._instance,
+  &::proto::_MessageKey_default_instance_._instance,
+  &::proto::_Money_default_instance_._instance,
+  &::proto::_MsgOpaqueData_PollOption_default_instance_._instance,
+  &::proto::_MsgOpaqueData_default_instance_._instance,
+  &::proto::_MsgRowOpaqueData_default_instance_._instance,
+  &::proto::_NoiseCertificate_Details_default_instance_._instance,
+  &::proto::_NoiseCertificate_default_instance_._instance,
+  &::proto::_NotificationMessageInfo_default_instance_._instance,
+  &::proto::_PastParticipant_default_instance_._instance,
+  &::proto::_PastParticipants_default_instance_._instance,
+  &::proto::_PaymentBackground_MediaData_default_instance_._instance,
+  &::proto::_PaymentBackground_default_instance_._instance,
+  &::proto::_PaymentInfo_default_instance_._instance,
+  &::proto::_PendingKeyExchange_default_instance_._instance,
+  &::proto::_PendingPreKey_default_instance_._instance,
+  &::proto::_PhotoChange_default_instance_._instance,
+  &::proto::_Point_default_instance_._instance,
+  &::proto::_PollAdditionalMetadata_default_instance_._instance,
+  &::proto::_PollEncValue_default_instance_._instance,
+  &::proto::_PollUpdate_default_instance_._instance,
+  &::proto::_PreKeyRecordStructure_default_instance_._instance,
+  &::proto::_Pushname_default_instance_._instance,
+  &::proto::_Reaction_default_instance_._instance,
+  &::proto::_RecentEmojiWeight_default_instance_._instance,
+  &::proto::_RecordStructure_default_instance_._instance,
+  &::proto::_SenderChainKey_default_instance_._instance,
+  &::proto::_SenderKeyRecordStructure_default_instance_._instance,
+  &::proto::_SenderKeyStateStructure_default_instance_._instance,
+  &::proto::_SenderMessageKey_default_instance_._instance,
+  &::proto::_SenderSigningKey_default_instance_._instance,
+  &::proto::_ServerErrorReceipt_default_instance_._instance,
+  &::proto::_SessionStructure_default_instance_._instance,
+  &::proto::_SignedPreKeyRecordStructure_default_instance_._instance,
+  &::proto::_StatusPSA_default_instance_._instance,
+  &::proto::_StickerMetadata_default_instance_._instance,
+  &::proto::_SyncActionData_default_instance_._instance,
+  &::proto::_SyncActionValue_AgentAction_default_instance_._instance,
+  &::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_._instance,
+  &::proto::_SyncActionValue_ArchiveChatAction_default_instance_._instance,
+  &::proto::_SyncActionValue_ClearChatAction_default_instance_._instance,
+  &::proto::_SyncActionValue_ContactAction_default_instance_._instance,
+  &::proto::_SyncActionValue_DeleteChatAction_default_instance_._instance,
+  &::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_._instance,
+  &::proto::_SyncActionValue_KeyExpiration_default_instance_._instance,
+  &::proto::_SyncActionValue_LabelAssociationAction_default_instance_._instance,
+  &::proto::_SyncActionValue_LabelEditAction_default_instance_._instance,
+  &::proto::_SyncActionValue_LocaleSetting_default_instance_._instance,
+  &::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_._instance,
+  &::proto::_SyncActionValue_MuteAction_default_instance_._instance,
+  &::proto::_SyncActionValue_NuxAction_default_instance_._instance,
+  &::proto::_SyncActionValue_PinAction_default_instance_._instance,
+  &::proto::_SyncActionValue_PrimaryFeature_default_instance_._instance,
+  &::proto::_SyncActionValue_PrimaryVersionAction_default_instance_._instance,
+  &::proto::_SyncActionValue_PushNameSetting_default_instance_._instance,
+  &::proto::_SyncActionValue_QuickReplyAction_default_instance_._instance,
+  &::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_._instance,
+  &::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_._instance,
+  &::proto::_SyncActionValue_StarAction_default_instance_._instance,
+  &::proto::_SyncActionValue_StickerAction_default_instance_._instance,
+  &::proto::_SyncActionValue_SubscriptionAction_default_instance_._instance,
+  &::proto::_SyncActionValue_SyncActionMessageRange_default_instance_._instance,
+  &::proto::_SyncActionValue_SyncActionMessage_default_instance_._instance,
+  &::proto::_SyncActionValue_TimeFormatAction_default_instance_._instance,
+  &::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_._instance,
+  &::proto::_SyncActionValue_UserStatusMuteAction_default_instance_._instance,
+  &::proto::_SyncActionValue_default_instance_._instance,
+  &::proto::_SyncdIndex_default_instance_._instance,
+  &::proto::_SyncdMutation_default_instance_._instance,
+  &::proto::_SyncdMutations_default_instance_._instance,
+  &::proto::_SyncdPatch_default_instance_._instance,
+  &::proto::_SyncdRecord_default_instance_._instance,
+  &::proto::_SyncdSnapshot_default_instance_._instance,
+  &::proto::_SyncdValue_default_instance_._instance,
+  &::proto::_SyncdVersion_default_instance_._instance,
+  &::proto::_TemplateButton_CallButton_default_instance_._instance,
+  &::proto::_TemplateButton_QuickReplyButton_default_instance_._instance,
+  &::proto::_TemplateButton_URLButton_default_instance_._instance,
+  &::proto::_TemplateButton_default_instance_._instance,
+  &::proto::_UserReceipt_default_instance_._instance,
+  &::proto::_VerifiedNameCertificate_Details_default_instance_._instance,
+  &::proto::_VerifiedNameCertificate_default_instance_._instance,
+  &::proto::_WallpaperSettings_default_instance_._instance,
+  &::proto::_WebFeatures_default_instance_._instance,
+  &::proto::_WebMessageInfo_default_instance_._instance,
+  &::proto::_WebNotificationsInfo_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_pmsg_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\npmsg.proto\022\005proto\"G\n\021ADVDeviceIdentity"
+  "\022\r\n\005rawId\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\020\n\010ke"
+  "yIndex\030\003 \001(\r\"c\n\017ADVKeyIndexList\022\r\n\005rawId"
+  "\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\024\n\014currentInde"
+  "x\030\003 \001(\r\022\030\n\014validIndexes\030\004 \003(\rB\002\020\001\"z\n\027ADV"
+  "SignedDeviceIdentity\022\017\n\007details\030\001 \001(\014\022\033\n"
+  "\023accountSignatureKey\030\002 \001(\014\022\030\n\020accountSig"
+  "nature\030\003 \001(\014\022\027\n\017deviceSignature\030\004 \001(\014\"<\n"
+  "\033ADVSignedDeviceIdentityHMAC\022\017\n\007details\030"
+  "\001 \001(\014\022\014\n\004hmac\030\002 \001(\014\"B\n\025ADVSignedKeyIndex"
+  "List\022\017\n\007details\030\001 \001(\014\022\030\n\020accountSignatur"
+  "e\030\002 \001(\014\".\n\nActionLink\022\013\n\003url\030\001 \001(\t\022\023\n\013bu"
+  "ttonTitle\030\002 \001(\t\"w\n\024AutoDownloadSettings\022"
+  "\026\n\016downloadImages\030\001 \001(\010\022\025\n\rdownloadAudio"
+  "\030\002 \001(\010\022\025\n\rdownloadVideo\030\003 \001(\010\022\031\n\021downloa"
+  "dDocuments\030\004 \001(\010\"\254\002\n\022BizAccountLinkInfo\022"
+  "\033\n\023whatsappBizAcctFbid\030\001 \001(\004\022\032\n\022whatsapp"
+  "AcctNumber\030\002 \001(\t\022\021\n\tissueTime\030\003 \001(\004\022>\n\013h"
+  "ostStorage\030\004 \001(\0162).proto.BizAccountLinkI"
+  "nfo.HostStorageType\022:\n\013accountType\030\005 \001(\016"
+  "2%.proto.BizAccountLinkInfo.AccountType\""
+  "\035\n\013AccountType\022\016\n\nENTERPRISE\020\000\"/\n\017HostSt"
+  "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\""
+  "_\n\021BizAccountPayload\0221\n\tvnameCert\030\001 \001(\0132"
+  "\036.proto.VerifiedNameCertificate\022\027\n\017bizAc"
+  "ctLinkInfo\030\002 \001(\014\"\332\003\n\017BizIdentityInfo\0229\n\006"
+  "vlevel\030\001 \001(\0162).proto.BizIdentityInfo.Ver"
+  "ifiedLevelValue\0221\n\tvnameCert\030\002 \001(\0132\036.pro"
+  "to.VerifiedNameCertificate\022\016\n\006signed\030\003 \001"
+  "(\010\022\017\n\007revoked\030\004 \001(\010\022;\n\013hostStorage\030\005 \001(\016"
+  "2&.proto.BizIdentityInfo.HostStorageType"
+  "\022=\n\014actualActors\030\006 \001(\0162\'.proto.BizIdenti"
+  "tyInfo.ActualActorsType\022\025\n\rprivacyModeTs"
+  "\030\007 \001(\004\022\027\n\017featureControls\030\010 \001(\004\"%\n\020Actua"
+  "lActorsType\022\010\n\004SELF\020\000\022\007\n\003BSP\020\001\"/\n\017HostSt"
+  "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\""
+  "4\n\022VerifiedLevelValue\022\013\n\007UNKNOWN\020\000\022\007\n\003LO"
+  "W\020\001\022\010\n\004HIGH\020\002\"\221\002\n\tCertChain\022/\n\004leaf\030\001 \001("
+  "\0132!.proto.CertChain.NoiseCertificate\0227\n\014"
+  "intermediate\030\002 \001(\0132!.proto.CertChain.Noi"
+  "seCertificate\032\231\001\n\020NoiseCertificate\022\017\n\007de"
+  "tails\030\001 \001(\014\022\021\n\tsignature\030\002 \001(\014\032a\n\007Detail"
+  "s\022\016\n\006serial\030\001 \001(\r\022\024\n\014issuerSerial\030\002 \001(\r\022"
+  "\013\n\003key\030\003 \001(\014\022\021\n\tnotBefore\030\004 \001(\004\022\020\n\010notAf"
+  "ter\030\005 \001(\004\"\215\001\n\005Chain\022\030\n\020senderRatchetKey\030"
+  "\001 \001(\014\022\037\n\027senderRatchetKeyPrivate\030\002 \001(\014\022!"
+  "\n\010chainKey\030\003 \001(\0132\017.proto.ChainKey\022&\n\013mes"
+  "sageKeys\030\004 \003(\0132\021.proto.MessageKey\"&\n\010Cha"
+  "inKey\022\r\n\005index\030\001 \001(\r\022\013\n\003key\030\002 \001(\014\"\326\031\n\rCl"
+  "ientPayload\022\020\n\010username\030\001 \001(\004\022\017\n\007passive"
+  "\030\003 \001(\010\0221\n\tuserAgent\030\005 \001(\0132\036.proto.Client"
+  "Payload.UserAgent\022-\n\007webInfo\030\006 \001(\0132\034.pro"
+  "to.ClientPayload.WebInfo\022\020\n\010pushName\030\007 \001"
+  "(\t\022\021\n\tsessionId\030\t \001(\017\022\024\n\014shortConnect\030\n "
+  "\001(\010\0225\n\013connectType\030\014 \001(\0162 .proto.ClientP"
+  "ayload.ConnectType\0229\n\rconnectReason\030\r \001("
+  "\0162\".proto.ClientPayload.ConnectReason\022\016\n"
+  "\006shards\030\016 \003(\005\0221\n\tdnsSource\030\017 \001(\0132\036.proto"
+  ".ClientPayload.DNSSource\022\033\n\023connectAttem"
+  "ptCount\030\020 \001(\r\022\016\n\006device\030\022 \001(\r\022M\n\021deviceP"
+  "airingData\030\023 \001(\01322.proto.ClientPayload.D"
+  "evicePairingRegistrationData\022-\n\007product\030"
+  "\024 \001(\0162\034.proto.ClientPayload.Product\022\r\n\005f"
+  "bCat\030\025 \001(\014\022\023\n\013fbUserAgent\030\026 \001(\014\022\n\n\002oc\030\027 "
+  "\001(\010\022\n\n\002lc\030\030 \001(\005\022=\n\017iosAppExtension\030\036 \001(\016"
+  "2$.proto.ClientPayload.IOSAppExtension\022\017"
+  "\n\007fbAppId\030\037 \001(\004\022\022\n\nfbDeviceId\030  \001(\014\022\014\n\004p"
+  "ull\030! \001(\010\022\024\n\014paddingBytes\030\" \001(\014\032\277\001\n\tDNSS"
+  "ource\022E\n\tdnsMethod\030\017 \001(\01622.proto.ClientP"
+  "ayload.DNSSource.DNSResolutionMethod\022\021\n\t"
+  "appCached\030\020 \001(\010\"X\n\023DNSResolutionMethod\022\n"
+  "\n\006SYSTEM\020\000\022\n\n\006GOOGLE\020\001\022\r\n\tHARDCODED\020\002\022\014\n"
+  "\010OVERRIDE\020\003\022\014\n\010FALLBACK\020\004\032\256\001\n\035DevicePair"
+  "ingRegistrationData\022\016\n\006eRegid\030\001 \001(\014\022\020\n\010e"
+  "Keytype\030\002 \001(\014\022\016\n\006eIdent\030\003 \001(\014\022\017\n\007eSkeyId"
+  "\030\004 \001(\014\022\020\n\010eSkeyVal\030\005 \001(\014\022\020\n\010eSkeySig\030\006 \001"
+  "(\014\022\021\n\tbuildHash\030\007 \001(\014\022\023\n\013deviceProps\030\010 \001"
+  "(\014\032\370\007\n\tUserAgent\0229\n\010platform\030\001 \001(\0162\'.pro"
+  "to.ClientPayload.UserAgent.Platform\022=\n\na"
+  "ppVersion\030\002 \001(\0132).proto.ClientPayload.Us"
+  "erAgent.AppVersion\022\013\n\003mcc\030\003 \001(\t\022\013\n\003mnc\030\004"
+  " \001(\t\022\021\n\tosVersion\030\005 \001(\t\022\024\n\014manufacturer\030"
+  "\006 \001(\t\022\016\n\006device\030\007 \001(\t\022\025\n\rosBuildNumber\030\010"
+  " \001(\t\022\017\n\007phoneId\030\t \001(\t\022E\n\016releaseChannel\030"
+  "\n \001(\0162-.proto.ClientPayload.UserAgent.Re"
+  "leaseChannel\022\035\n\025localeLanguageIso6391\030\013 "
+  "\001(\t\022#\n\033localeCountryIso31661Alpha2\030\014 \001(\t"
+  "\022\023\n\013deviceBoard\030\r \001(\t\032g\n\nAppVersion\022\017\n\007p"
+  "rimary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010terti"
+  "ary\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary"
+  "\030\005 \001(\r\"\255\003\n\010Platform\022\013\n\007ANDROID\020\000\022\007\n\003IOS\020"
+  "\001\022\021\n\rWINDOWS_PHONE\020\002\022\016\n\nBLACKBERRY\020\003\022\017\n\013"
+  "BLACKBERRYX\020\004\022\007\n\003S40\020\005\022\007\n\003S60\020\006\022\021\n\rPYTHO"
+  "N_CLIENT\020\007\022\t\n\005TIZEN\020\010\022\016\n\nENTERPRISE\020\t\022\017\n"
+  "\013SMB_ANDROID\020\n\022\t\n\005KAIOS\020\013\022\013\n\007SMB_IOS\020\014\022\013"
+  "\n\007WINDOWS\020\r\022\007\n\003WEB\020\016\022\n\n\006PORTAL\020\017\022\021\n\rGREE"
+  "N_ANDROID\020\020\022\020\n\014GREEN_IPHONE\020\021\022\020\n\014BLUE_AN"
+  "DROID\020\022\022\017\n\013BLUE_IPHONE\020\023\022\022\n\016FBLITE_ANDRO"
+  "ID\020\024\022\021\n\rMLITE_ANDROID\020\025\022\022\n\016IGLITE_ANDROI"
+  "D\020\026\022\010\n\004PAGE\020\027\022\t\n\005MACOS\020\030\022\016\n\nOCULUS_MSG\020\031"
+  "\022\017\n\013OCULUS_CALL\020\032\022\t\n\005MILAN\020\033\022\010\n\004CAPI\020\034\"="
+  "\n\016ReleaseChannel\022\013\n\007RELEASE\020\000\022\010\n\004BETA\020\001\022"
+  "\t\n\005ALPHA\020\002\022\t\n\005DEBUG\020\003\032\306\004\n\007WebInfo\022\020\n\010ref"
+  "Token\030\001 \001(\t\022\017\n\007version\030\002 \001(\t\022=\n\013webdPayl"
+  "oad\030\003 \001(\0132(.proto.ClientPayload.WebInfo."
+  "WebdPayload\022C\n\016webSubPlatform\030\004 \001(\0162+.pr"
+  "oto.ClientPayload.WebInfo.WebSubPlatform"
+  "\032\273\002\n\013WebdPayload\022\034\n\024usesParticipantInKey"
+  "\030\001 \001(\010\022\037\n\027supportsStarredMessages\030\002 \001(\010\022"
+  " \n\030supportsDocumentMessages\030\003 \001(\010\022\033\n\023sup"
+  "portsUrlMessages\030\004 \001(\010\022\032\n\022supportsMediaR"
+  "etry\030\005 \001(\010\022\030\n\020supportsE2EImage\030\006 \001(\010\022\030\n\020"
+  "supportsE2EVideo\030\007 \001(\010\022\030\n\020supportsE2EAud"
+  "io\030\010 \001(\010\022\033\n\023supportsE2EDocument\030\t \001(\010\022\025\n"
+  "\rdocumentTypes\030\n \001(\t\022\020\n\010features\030\013 \001(\014\"V"
+  "\n\016WebSubPlatform\022\017\n\013WEB_BROWSER\020\000\022\r\n\tAPP"
+  "_STORE\020\001\022\r\n\tWIN_STORE\020\002\022\n\n\006DARWIN\020\003\022\t\n\005W"
+  "INDA\020\004\"y\n\rConnectReason\022\010\n\004PUSH\020\000\022\022\n\016USE"
+  "R_ACTIVATED\020\001\022\r\n\tSCHEDULED\020\002\022\023\n\017ERROR_RE"
+  "CONNECT\020\003\022\022\n\016NETWORK_SWITCH\020\004\022\022\n\016PING_RE"
+  "CONNECT\020\005\"\260\002\n\013ConnectType\022\024\n\020CELLULAR_UN"
+  "KNOWN\020\000\022\020\n\014WIFI_UNKNOWN\020\001\022\021\n\rCELLULAR_ED"
+  "GE\020d\022\021\n\rCELLULAR_IDEN\020e\022\021\n\rCELLULAR_UMTS"
+  "\020f\022\021\n\rCELLULAR_EVDO\020g\022\021\n\rCELLULAR_GPRS\020h"
+  "\022\022\n\016CELLULAR_HSDPA\020i\022\022\n\016CELLULAR_HSUPA\020j"
+  "\022\021\n\rCELLULAR_HSPA\020k\022\021\n\rCELLULAR_CDMA\020l\022\022"
+  "\n\016CELLULAR_1XRTT\020m\022\022\n\016CELLULAR_EHRPD\020n\022\020"
+  "\n\014CELLULAR_LTE\020o\022\022\n\016CELLULAR_HSPAP\020p\"T\n\017"
+  "IOSAppExtension\022\023\n\017SHARE_EXTENSION\020\000\022\025\n\021"
+  "SERVICE_EXTENSION\020\001\022\025\n\021INTENTS_EXTENSION"
+  "\020\002\"&\n\007Product\022\014\n\010WHATSAPP\020\000\022\r\n\tMESSENGER"
+  "\020\001\"\231\n\n\013ContextInfo\022\020\n\010stanzaId\030\001 \001(\t\022\023\n\013"
+  "participant\030\002 \001(\t\022%\n\rquotedMessage\030\003 \001(\013"
+  "2\016.proto.Message\022\021\n\tremoteJid\030\004 \001(\t\022\024\n\014m"
+  "entionedJid\030\017 \003(\t\022\030\n\020conversionSource\030\022 "
+  "\001(\t\022\026\n\016conversionData\030\023 \001(\014\022\036\n\026conversio"
+  "nDelaySeconds\030\024 \001(\r\022\027\n\017forwardingScore\030\025"
+  " \001(\r\022\023\n\013isForwarded\030\026 \001(\010\0220\n\010quotedAd\030\027 "
+  "\001(\0132\036.proto.ContextInfo.AdReplyInfo\022)\n\016p"
+  "laceholderKey\030\030 \001(\0132\021.proto.MessageKey\022\022"
+  "\n\nexpiration\030\031 \001(\r\022!\n\031ephemeralSettingTi"
+  "mestamp\030\032 \001(\003\022\035\n\025ephemeralSharedSecret\030\033"
+  " \001(\014\022\?\n\017externalAdReply\030\034 \001(\0132&.proto.Co"
+  "ntextInfo.ExternalAdReplyInfo\022\"\n\032entryPo"
+  "intConversionSource\030\035 \001(\t\022\037\n\027entryPointC"
+  "onversionApp\030\036 \001(\t\022(\n entryPointConversi"
+  "onDelaySeconds\030\037 \001(\r\0221\n\020disappearingMode"
+  "\030  \001(\0132\027.proto.DisappearingMode\022%\n\nactio"
+  "nLink\030! \001(\0132\021.proto.ActionLink\022\024\n\014groupS"
+  "ubject\030\" \001(\t\022\026\n\016parentGroupJid\030# \001(\t\032\267\001\n"
+  "\013AdReplyInfo\022\026\n\016advertiserName\030\001 \001(\t\022;\n\t"
+  "mediaType\030\002 \001(\0162(.proto.ContextInfo.AdRe"
+  "plyInfo.MediaType\022\025\n\rjpegThumbnail\030\020 \001(\014"
+  "\022\017\n\007caption\030\021 \001(\t\"+\n\tMediaType\022\010\n\004NONE\020\000"
+  "\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\032\355\002\n\023ExternalAdRep"
+  "lyInfo\022\r\n\005title\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\022C\n\tm"
+  "ediaType\030\003 \001(\01620.proto.ContextInfo.Exter"
+  "nalAdReplyInfo.MediaType\022\024\n\014thumbnailUrl"
+  "\030\004 \001(\t\022\020\n\010mediaUrl\030\005 \001(\t\022\021\n\tthumbnail\030\006 "
+  "\001(\014\022\022\n\nsourceType\030\007 \001(\t\022\020\n\010sourceId\030\010 \001("
+  "\t\022\021\n\tsourceUrl\030\t \001(\t\022\031\n\021containsAutoRepl"
+  "y\030\n \001(\010\022\035\n\025renderLargerThumbnail\030\013 \001(\010\022\031"
+  "\n\021showAdAttribution\030\014 \001(\010\"+\n\tMediaType\022\010"
+  "\n\004NONE\020\000\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\"\261\t\n\014Conve"
+  "rsation\022\n\n\002id\030\001 \002(\t\022\'\n\010messages\030\002 \003(\0132\025."
+  "proto.HistorySyncMsg\022\016\n\006newJid\030\003 \001(\t\022\016\n\006"
+  "oldJid\030\004 \001(\t\022\030\n\020lastMsgTimestamp\030\005 \001(\004\022\023"
+  "\n\013unreadCount\030\006 \001(\r\022\020\n\010readOnly\030\007 \001(\010\022\034\n"
+  "\024endOfHistoryTransfer\030\010 \001(\010\022\033\n\023ephemeral"
+  "Expiration\030\t \001(\r\022!\n\031ephemeralSettingTime"
+  "stamp\030\n \001(\003\022N\n\030endOfHistoryTransferType\030"
+  "\013 \001(\0162,.proto.Conversation.EndOfHistoryT"
+  "ransferType\022\035\n\025conversationTimestamp\030\014 \001"
+  "(\004\022\014\n\004name\030\r \001(\t\022\r\n\005pHash\030\016 \001(\t\022\017\n\007notSp"
+  "am\030\017 \001(\010\022\020\n\010archived\030\020 \001(\010\0221\n\020disappeari"
+  "ngMode\030\021 \001(\0132\027.proto.DisappearingMode\022\032\n"
+  "\022unreadMentionCount\030\022 \001(\r\022\026\n\016markedAsUnr"
+  "ead\030\023 \001(\010\022,\n\013participant\030\024 \003(\0132\027.proto.G"
+  "roupParticipant\022\017\n\007tcToken\030\025 \001(\014\022\030\n\020tcTo"
+  "kenTimestamp\030\026 \001(\004\022!\n\031contactPrimaryIden"
+  "tityKey\030\027 \001(\014\022\016\n\006pinned\030\030 \001(\r\022\023\n\013muteEnd"
+  "Time\030\031 \001(\004\022+\n\twallpaper\030\032 \001(\0132\030.proto.Wa"
+  "llpaperSettings\022/\n\017mediaVisibility\030\033 \001(\016"
+  "2\026.proto.MediaVisibility\022\036\n\026tcTokenSende"
+  "rTimestamp\030\034 \001(\004\022\021\n\tsuspended\030\035 \001(\010\022\022\n\nt"
+  "erminated\030\036 \001(\010\022\021\n\tcreatedAt\030\037 \001(\004\022\021\n\tcr"
+  "eatedBy\030  \001(\t\022\023\n\013description\030! \001(\t\022\017\n\007su"
+  "pport\030\" \001(\010\022\025\n\risParentGroup\030# \001(\010\022\031\n\021is"
+  "DefaultSubgroup\030$ \001(\010\022\025\n\rparentGroupId\030%"
+  " \001(\t\022\023\n\013displayName\030& \001(\t\022\r\n\005pnJid\030\' \001(\t"
+  "\022\025\n\rselfPnExposed\030( \001(\010\"\200\001\n\030EndOfHistory"
+  "TransferType\0220\n,COMPLETE_BUT_MORE_MESSAG"
+  "ES_REMAIN_ON_PRIMARY\020\000\0222\n.COMPLETE_AND_N"
+  "O_MORE_MESSAGE_REMAIN_ON_PRIMARY\020\001\"\271\001\n\022D"
+  "eviceListMetadata\022\025\n\rsenderKeyHash\030\001 \001(\014"
+  "\022\027\n\017senderTimestamp\030\002 \001(\004\022\034\n\020senderKeyIn"
+  "dexes\030\003 \003(\rB\002\020\001\022\030\n\020recipientKeyHash\030\010 \001("
+  "\014\022\032\n\022recipientTimestamp\030\t \001(\004\022\037\n\023recipie"
+  "ntKeyIndexes\030\n \003(\rB\002\020\001\"\275\003\n\013DeviceProps\022\n"
+  "\n\002os\030\001 \001(\t\022.\n\007version\030\002 \001(\0132\035.proto.Devi"
+  "ceProps.AppVersion\0225\n\014platformType\030\003 \001(\016"
+  "2\037.proto.DeviceProps.PlatformType\022\027\n\017req"
+  "uireFullSync\030\004 \001(\010\032g\n\nAppVersion\022\017\n\007prim"
+  "ary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010tertiary"
+  "\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary\030\005 "
+  "\001(\r\"\270\001\n\014PlatformType\022\013\n\007UNKNOWN\020\000\022\n\n\006CHR"
+  "OME\020\001\022\013\n\007FIREFOX\020\002\022\006\n\002IE\020\003\022\t\n\005OPERA\020\004\022\n\n"
+  "\006SAFARI\020\005\022\010\n\004EDGE\020\006\022\013\n\007DESKTOP\020\007\022\010\n\004IPAD"
+  "\020\010\022\022\n\016ANDROID_TABLET\020\t\022\t\n\005OHANA\020\n\022\t\n\005ALO"
+  "HA\020\013\022\014\n\010CATALINA\020\014\022\n\n\006TCL_TV\020\r\"\227\001\n\020Disap"
+  "pearingMode\0224\n\tinitiator\030\001 \001(\0162!.proto.D"
+  "isappearingMode.Initiator\"M\n\tInitiator\022\023"
+  "\n\017CHANGED_IN_CHAT\020\000\022\023\n\017INITIATED_BY_ME\020\001"
+  "\022\026\n\022INITIATED_BY_OTHER\020\002\"7\n\020EphemeralSet"
+  "ting\022\020\n\010duration\030\001 \001(\017\022\021\n\ttimestamp\030\002 \001("
+  "\020\"&\n\010ExitCode\022\014\n\004code\030\001 \001(\004\022\014\n\004text\030\002 \001("
+  "\t\"\217\001\n\025ExternalBlobReference\022\020\n\010mediaKey\030"
+  "\001 \001(\014\022\022\n\ndirectPath\030\002 \001(\t\022\016\n\006handle\030\003 \001("
+  "\t\022\025\n\rfileSizeBytes\030\004 \001(\004\022\022\n\nfileSha256\030\005"
+  " \001(\014\022\025\n\rfileEncSha256\030\006 \001(\014\"\362\003\n\016GlobalSe"
+  "ttings\0225\n\023lightThemeWallpaper\030\001 \001(\0132\030.pr"
+  "oto.WallpaperSettings\022/\n\017mediaVisibility"
+  "\030\002 \001(\0162\026.proto.MediaVisibility\0224\n\022darkTh"
+  "emeWallpaper\030\003 \001(\0132\030.proto.WallpaperSett"
+  "ings\0225\n\020autoDownloadWiFi\030\004 \001(\0132\033.proto.A"
+  "utoDownloadSettings\0229\n\024autoDownloadCellu"
+  "lar\030\005 \001(\0132\033.proto.AutoDownloadSettings\0228"
+  "\n\023autoDownloadRoaming\030\006 \001(\0132\033.proto.Auto"
+  "DownloadSettings\022*\n\"showIndividualNotifi"
+  "cationsPreview\030\007 \001(\010\022%\n\035showGroupNotific"
+  "ationsPreview\030\010 \001(\010\022 \n\030disappearingModeD"
+  "uration\030\t \001(\005\022!\n\031disappearingModeTimesta"
+  "mp\030\n \001(\003\"\177\n\020GroupParticipant\022\017\n\007userJid\030"
+  "\001 \002(\t\022*\n\004rank\030\002 \001(\0162\034.proto.GroupPartici"
+  "pant.Rank\".\n\004Rank\022\013\n\007REGULAR\020\000\022\t\n\005ADMIN\020"
+  "\001\022\016\n\nSUPERADMIN\020\002\"\371\002\n\020HandshakeMessage\0228"
+  "\n\013clientHello\030\002 \001(\0132#.proto.HandshakeMes"
+  "sage.ClientHello\0228\n\013serverHello\030\003 \001(\0132#."
+  "proto.HandshakeMessage.ServerHello\022:\n\014cl"
+  "ientFinish\030\004 \001(\0132$.proto.HandshakeMessag"
+  "e.ClientFinish\032/\n\014ClientFinish\022\016\n\006static"
+  "\030\001 \001(\014\022\017\n\007payload\030\002 \001(\014\032A\n\013ClientHello\022\021"
+  "\n\tephemeral\030\001 \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007pay"
+  "load\030\003 \001(\014\032A\n\013ServerHello\022\021\n\tephemeral\030\001"
+  " \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007payload\030\003 \001(\014\"\264\004"
+  "\n\013HistorySync\0224\n\010syncType\030\001 \002(\0162\".proto."
+  "HistorySync.HistorySyncType\022*\n\rconversat"
+  "ions\030\002 \003(\0132\023.proto.Conversation\022/\n\020statu"
+  "sV3Messages\030\003 \003(\0132\025.proto.WebMessageInfo"
+  "\022\022\n\nchunkOrder\030\005 \001(\r\022\020\n\010progress\030\006 \001(\r\022\""
+  "\n\tpushnames\030\007 \003(\0132\017.proto.Pushname\022-\n\016gl"
+  "obalSettings\030\010 \001(\0132\025.proto.GlobalSetting"
+  "s\022\032\n\022threadIdUserSecret\030\t \001(\014\022\037\n\027threadD"
+  "sTimeframeOffset\030\n \001(\r\022.\n\016recentStickers"
+  "\030\013 \003(\0132\026.proto.StickerMetadata\0221\n\020pastPa"
+  "rticipants\030\014 \003(\0132\027.proto.PastParticipant"
+  "s\"y\n\017HistorySyncType\022\025\n\021INITIAL_BOOTSTRA"
+  "P\020\000\022\025\n\021INITIAL_STATUS_V3\020\001\022\010\n\004FULL\020\002\022\n\n\006"
+  "RECENT\020\003\022\r\n\tPUSH_NAME\020\004\022\023\n\017UNBLOCKING_DA"
+  "TA\020\005\"L\n\016HistorySyncMsg\022&\n\007message\030\001 \001(\0132"
+  "\025.proto.WebMessageInfo\022\022\n\nmsgOrderId\030\002 \001"
+  "(\004\"\317\003\n\026HydratedTemplateButton\022\r\n\005index\030\004"
+  " \001(\r\022R\n\020quickReplyButton\030\001 \001(\01326.proto.H"
+  "ydratedTemplateButton.HydratedQuickReply"
+  "ButtonH\000\022D\n\turlButton\030\002 \001(\0132/.proto.Hydr"
+  "atedTemplateButton.HydratedURLButtonH\000\022F"
+  "\n\ncallButton\030\003 \001(\01320.proto.HydratedTempl"
+  "ateButton.HydratedCallButtonH\000\032>\n\022Hydrat"
+  "edCallButton\022\023\n\013displayText\030\001 \001(\t\022\023\n\013pho"
+  "neNumber\030\002 \001(\t\032;\n\030HydratedQuickReplyButt"
+  "on\022\023\n\013displayText\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\0325\n\021H"
+  "ydratedURLButton\022\023\n\013displayText\030\001 \001(\t\022\013\n"
+  "\003url\030\002 \001(\tB\020\n\016hydratedButton\"A\n\030Identity"
+  "KeyPairStructure\022\021\n\tpublicKey\030\001 \001(\014\022\022\n\np"
+  "rivateKey\030\002 \001(\014\"m\n\025InteractiveAnnotation"
+  "\022%\n\017polygonVertices\030\001 \003(\0132\014.proto.Point\022"
+  "#\n\010location\030\002 \001(\0132\017.proto.LocationH\000B\010\n\006"
+  "action\"{\n\nKeepInChat\022!\n\010keepType\030\001 \001(\0162\017"
+  ".proto.KeepType\022\027\n\017serverTimestamp\030\002 \001(\003"
+  "\022\036\n\003key\030\003 \001(\0132\021.proto.MessageKey\022\021\n\tdevi"
+  "ceJid\030\004 \001(\t\"\023\n\005KeyId\022\n\n\002id\030\001 \001(\014\"=\n\rLoca"
+  "lizedName\022\n\n\002lg\030\001 \001(\t\022\n\n\002lc\030\002 \001(\t\022\024\n\014ver"
+  "ifiedName\030\003 \001(\t\"K\n\010Location\022\027\n\017degreesLa"
+  "titude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001\022\014"
+  "\n\004name\030\003 \001(\t\"\036\n\tMediaData\022\021\n\tlocalPath\030\001"
+  " \001(\t\"\313\001\n\026MediaRetryNotification\022\020\n\010stanz"
+  "aId\030\001 \001(\t\022\022\n\ndirectPath\030\002 \001(\t\0228\n\006result\030"
+  "\003 \001(\0162(.proto.MediaRetryNotification.Res"
+  "ultType\"Q\n\nResultType\022\021\n\rGENERAL_ERROR\020\000"
+  "\022\013\n\007SUCCESS\020\001\022\r\n\tNOT_FOUND\020\002\022\024\n\020DECRYPTI"
+  "ON_ERROR\020\003\"\335\237\001\n\007Message\022\024\n\014conversation\030"
+  "\001 \001(\t\022Q\n\034senderKeyDistributionMessage\030\002 "
+  "\001(\0132+.proto.Message.SenderKeyDistributio"
+  "nMessage\0221\n\014imageMessage\030\003 \001(\0132\033.proto.M"
+  "essage.ImageMessage\0225\n\016contactMessage\030\004 "
+  "\001(\0132\035.proto.Message.ContactMessage\0227\n\017lo"
+  "cationMessage\030\005 \001(\0132\036.proto.Message.Loca"
+  "tionMessage\022\?\n\023extendedTextMessage\030\006 \001(\013"
+  "2\".proto.Message.ExtendedTextMessage\0227\n\017"
+  "documentMessage\030\007 \001(\0132\036.proto.Message.Do"
+  "cumentMessage\0221\n\014audioMessage\030\010 \001(\0132\033.pr"
+  "oto.Message.AudioMessage\0221\n\014videoMessage"
+  "\030\t \001(\0132\033.proto.Message.VideoMessage\022!\n\004c"
+  "all\030\n \001(\0132\023.proto.Message.Call\022!\n\004chat\030\013"
+  " \001(\0132\023.proto.Message.Chat\0227\n\017protocolMes"
+  "sage\030\014 \001(\0132\036.proto.Message.ProtocolMessa"
+  "ge\022A\n\024contactsArrayMessage\030\r \001(\0132#.proto"
+  ".Message.ContactsArrayMessage\022G\n\027highlyS"
+  "tructuredMessage\030\016 \001(\0132&.proto.Message.H"
+  "ighlyStructuredMessage\022_\n*fastRatchetKey"
+  "SenderKeyDistributionMessage\030\017 \001(\0132+.pro"
+  "to.Message.SenderKeyDistributionMessage\022"
+  "=\n\022sendPaymentMessage\030\020 \001(\0132!.proto.Mess"
+  "age.SendPaymentMessage\022\?\n\023liveLocationMe"
+  "ssage\030\022 \001(\0132\".proto.Message.LiveLocation"
+  "Message\022C\n\025requestPaymentMessage\030\026 \001(\0132$"
+  ".proto.Message.RequestPaymentMessage\022Q\n\034"
+  "declinePaymentRequestMessage\030\027 \001(\0132+.pro"
+  "to.Message.DeclinePaymentRequestMessage\022"
+  "O\n\033cancelPaymentRequestMessage\030\030 \001(\0132*.p"
+  "roto.Message.CancelPaymentRequestMessage"
+  "\0227\n\017templateMessage\030\031 \001(\0132\036.proto.Messag"
+  "e.TemplateMessage\0225\n\016stickerMessage\030\032 \001("
+  "\0132\035.proto.Message.StickerMessage\022=\n\022grou"
+  "pInviteMessage\030\034 \001(\0132!.proto.Message.Gro"
+  "upInviteMessage\022M\n\032templateButtonReplyMe"
+  "ssage\030\035 \001(\0132).proto.Message.TemplateButt"
+  "onReplyMessage\0225\n\016productMessage\030\036 \001(\0132\035"
+  ".proto.Message.ProductMessage\022;\n\021deviceS"
+  "entMessage\030\037 \001(\0132 .proto.Message.DeviceS"
+  "entMessage\0225\n\022messageContextInfo\030# \001(\0132\031"
+  ".proto.MessageContextInfo\022/\n\013listMessage"
+  "\030$ \001(\0132\032.proto.Message.ListMessage\022:\n\017vi"
+  "ewOnceMessage\030% \001(\0132!.proto.Message.Futu"
+  "reProofMessage\0221\n\014orderMessage\030& \001(\0132\033.p"
+  "roto.Message.OrderMessage\022\?\n\023listRespons"
+  "eMessage\030\' \001(\0132\".proto.Message.ListRespo"
+  "nseMessage\022;\n\020ephemeralMessage\030( \001(\0132!.p"
+  "roto.Message.FutureProofMessage\0225\n\016invoi"
+  "ceMessage\030) \001(\0132\035.proto.Message.InvoiceM"
+  "essage\0225\n\016buttonsMessage\030* \001(\0132\035.proto.M"
+  "essage.ButtonsMessage\022E\n\026buttonsResponse"
+  "Message\030+ \001(\0132%.proto.Message.ButtonsRes"
+  "ponseMessage\022A\n\024paymentInviteMessage\030, \001"
+  "(\0132#.proto.Message.PaymentInviteMessage\022"
+  "=\n\022interactiveMessage\030- \001(\0132!.proto.Mess"
+  "age.InteractiveMessage\0227\n\017reactionMessag"
+  "e\030. \001(\0132\036.proto.Message.ReactionMessage\022"
+  "C\n\025stickerSyncRmrMessage\030/ \001(\0132$.proto.M"
+  "essage.StickerSyncRMRMessage\022M\n\032interact"
+  "iveResponseMessage\0300 \001(\0132).proto.Message"
+  ".InteractiveResponseMessage\022\?\n\023pollCreat"
+  "ionMessage\0301 \001(\0132\".proto.Message.PollCre"
+  "ationMessage\022;\n\021pollUpdateMessage\0302 \001(\0132"
+  " .proto.Message.PollUpdateMessage\022;\n\021kee"
+  "pInChatMessage\0303 \001(\0132 .proto.Message.Kee"
+  "pInChatMessage\022E\n\032documentWithCaptionMes"
+  "sage\0305 \001(\0132!.proto.Message.FutureProofMe"
+  "ssage\022K\n\031requestPhoneNumberMessage\0306 \001(\013"
+  "2(.proto.Message.RequestPhoneNumberMessa"
+  "ge\022<\n\021viewOnceMessageV2\0307 \001(\0132!.proto.Me"
+  "ssage.FutureProofMessage\032P\n\"AppStateFata"
+  "lExceptionNotification\022\027\n\017collectionName"
+  "s\030\001 \003(\t\022\021\n\ttimestamp\030\002 \001(\003\032y\n\023AppStateSy"
+  "ncKeyData\022\017\n\007keyData\030\001 \001(\014\022>\n\013fingerprin"
+  "t\030\002 \001(\0132).proto.Message.AppStateSyncKeyF"
+  "ingerprint\022\021\n\ttimestamp\030\003 \001(\003\032\\\n\032AppStat"
+  "eSyncKeyFingerprint\022\r\n\005rawId\030\001 \001(\r\022\024\n\014cu"
+  "rrentIndex\030\002 \001(\r\022\031\n\rdeviceIndexes\030\003 \003(\rB"
+  "\002\020\001\032\"\n\021AppStateSyncKeyId\022\r\n\005keyId\030\001 \001(\014\032"
+  "J\n\026AppStateSyncKeyRequest\0220\n\006keyIds\030\001 \003("
+  "\0132 .proto.Message.AppStateSyncKeyId\032D\n\024A"
+  "ppStateSyncKeyShare\022,\n\004keys\030\001 \003(\0132\036.prot"
+  "o.Message.AppStateSyncKey\032w\n\017AppStateSyn"
+  "cKey\022/\n\005keyId\030\001 \001(\0132 .proto.Message.AppS"
+  "tateSyncKeyId\0223\n\007keyData\030\002 \001(\0132\".proto.M"
+  "essage.AppStateSyncKeyData\032\240\002\n\014AudioMess"
+  "age\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetype\030\002 \001(\t\022\022\n\nfi"
+  "leSha256\030\003 \001(\014\022\022\n\nfileLength\030\004 \001(\004\022\017\n\007se"
+  "conds\030\005 \001(\r\022\013\n\003ptt\030\006 \001(\010\022\020\n\010mediaKey\030\007 \001"
+  "(\014\022\025\n\rfileEncSha256\030\010 \001(\014\022\022\n\ndirectPath\030"
+  "\t \001(\t\022\031\n\021mediaKeyTimestamp\030\n \001(\003\022\'\n\013cont"
+  "extInfo\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020str"
+  "eamingSidecar\030\022 \001(\014\022\020\n\010waveform\030\023 \001(\014\032\246\007"
+  "\n\016ButtonsMessage\022\023\n\013contentText\030\006 \001(\t\022\022\n"
+  "\nfooterText\030\007 \001(\t\022\'\n\013contextInfo\030\010 \001(\0132\022"
+  ".proto.ContextInfo\0225\n\007buttons\030\t \003(\0132$.pr"
+  "oto.Message.ButtonsMessage.Button\022<\n\nhea"
+  "derType\030\n \001(\0162(.proto.Message.ButtonsMes"
+  "sage.HeaderType\022\016\n\004text\030\001 \001(\tH\000\0229\n\017docum"
+  "entMessage\030\002 \001(\0132\036.proto.Message.Documen"
+  "tMessageH\000\0223\n\014imageMessage\030\003 \001(\0132\033.proto"
+  ".Message.ImageMessageH\000\0223\n\014videoMessage\030"
+  "\004 \001(\0132\033.proto.Message.VideoMessageH\000\0229\n\017"
+  "locationMessage\030\005 \001(\0132\036.proto.Message.Lo"
+  "cationMessageH\000\032\360\002\n\006Button\022\020\n\010buttonId\030\001"
+  " \001(\t\022C\n\nbuttonText\030\002 \001(\0132/.proto.Message"
+  ".ButtonsMessage.Button.ButtonText\0227\n\004typ"
+  "e\030\003 \001(\0162).proto.Message.ButtonsMessage.B"
+  "utton.Type\022K\n\016nativeFlowInfo\030\004 \001(\01323.pro"
+  "to.Message.ButtonsMessage.Button.NativeF"
+  "lowInfo\032!\n\nButtonText\022\023\n\013displayText\030\001 \001"
+  "(\t\0322\n\016NativeFlowInfo\022\014\n\004name\030\001 \001(\t\022\022\n\npa"
+  "ramsJson\030\002 \001(\t\"2\n\004Type\022\013\n\007UNKNOWN\020\000\022\014\n\010R"
+  "ESPONSE\020\001\022\017\n\013NATIVE_FLOW\020\002\"`\n\nHeaderType"
+  "\022\013\n\007UNKNOWN\020\000\022\t\n\005EMPTY\020\001\022\010\n\004TEXT\020\002\022\014\n\010DO"
+  "CUMENT\020\003\022\t\n\005IMAGE\020\004\022\t\n\005VIDEO\020\005\022\014\n\010LOCATI"
+  "ON\020\006B\010\n\006header\032\347\001\n\026ButtonsResponseMessag"
+  "e\022\030\n\020selectedButtonId\030\001 \001(\t\022\'\n\013contextIn"
+  "fo\030\003 \001(\0132\022.proto.ContextInfo\0228\n\004type\030\004 \001"
+  "(\0162*.proto.Message.ButtonsResponseMessag"
+  "e.Type\022\035\n\023selectedDisplayText\030\002 \001(\tH\000\"%\n"
+  "\004Type\022\013\n\007UNKNOWN\020\000\022\020\n\014DISPLAY_TEXT\020\001B\n\n\010"
+  "response\032i\n\004Call\022\017\n\007callKey\030\001 \001(\014\022\030\n\020con"
+  "versionSource\030\002 \001(\t\022\026\n\016conversionData\030\003 "
+  "\001(\014\022\036\n\026conversionDelaySeconds\030\004 \001(\r\032=\n\033C"
+  "ancelPaymentRequestMessage\022\036\n\003key\030\001 \001(\0132"
+  "\021.proto.MessageKey\032\'\n\004Chat\022\023\n\013displayNam"
+  "e\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\032]\n\016ContactMessage\022\023\n"
+  "\013displayName\030\001 \001(\t\022\r\n\005vcard\030\020 \001(\t\022\'\n\013con"
+  "textInfo\030\021 \001(\0132\022.proto.ContextInfo\032\205\001\n\024C"
+  "ontactsArrayMessage\022\023\n\013displayName\030\001 \001(\t"
+  "\022/\n\010contacts\030\002 \003(\0132\035.proto.Message.Conta"
+  "ctMessage\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C"
+  "ontextInfo\032>\n\034DeclinePaymentRequestMessa"
+  "ge\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey\032[\n\021De"
+  "viceSentMessage\022\026\n\016destinationJid\030\001 \001(\t\022"
+  "\037\n\007message\030\002 \001(\0132\016.proto.Message\022\r\n\005phas"
+  "h\030\003 \001(\t\032\316\003\n\017DocumentMessage\022\013\n\003url\030\001 \001(\t"
+  "\022\020\n\010mimetype\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\022\n\nfil"
+  "eSha256\030\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\021\n\tpag"
+  "eCount\030\006 \001(\r\022\020\n\010mediaKey\030\007 \001(\014\022\020\n\010fileNa"
+  "me\030\010 \001(\t\022\025\n\rfileEncSha256\030\t \001(\014\022\022\n\ndirec"
+  "tPath\030\n \001(\t\022\031\n\021mediaKeyTimestamp\030\013 \001(\003\022\024"
+  "\n\014contactVcard\030\014 \001(\010\022\033\n\023thumbnailDirectP"
+  "ath\030\r \001(\t\022\027\n\017thumbnailSha256\030\016 \001(\014\022\032\n\022th"
+  "umbnailEncSha256\030\017 \001(\014\022\025\n\rjpegThumbnail\030"
+  "\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.Conte"
+  "xtInfo\022\027\n\017thumbnailHeight\030\022 \001(\r\022\026\n\016thumb"
+  "nailWidth\030\023 \001(\r\022\017\n\007caption\030\024 \001(\t\032\211\010\n\023Ext"
+  "endedTextMessage\022\014\n\004text\030\001 \001(\t\022\023\n\013matche"
+  "dText\030\002 \001(\t\022\024\n\014canonicalUrl\030\004 \001(\t\022\023\n\013des"
+  "cription\030\005 \001(\t\022\r\n\005title\030\006 \001(\t\022\020\n\010textArg"
+  "b\030\007 \001(\007\022\026\n\016backgroundArgb\030\010 \001(\007\0229\n\004font\030"
+  "\t \001(\0162+.proto.Message.ExtendedTextMessag"
+  "e.FontType\022C\n\013previewType\030\n \001(\0162..proto."
+  "Message.ExtendedTextMessage.PreviewType\022"
+  "\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 "
+  "\001(\0132\022.proto.ContextInfo\022\027\n\017doNotPlayInli"
+  "ne\030\022 \001(\010\022\033\n\023thumbnailDirectPath\030\023 \001(\t\022\027\n"
+  "\017thumbnailSha256\030\024 \001(\014\022\032\n\022thumbnailEncSh"
+  "a256\030\025 \001(\014\022\020\n\010mediaKey\030\026 \001(\014\022\031\n\021mediaKey"
+  "Timestamp\030\027 \001(\003\022\027\n\017thumbnailHeight\030\030 \001(\r"
+  "\022\026\n\016thumbnailWidth\030\031 \001(\r\022S\n\023inviteLinkGr"
+  "oupType\030\032 \001(\01626.proto.Message.ExtendedTe"
+  "xtMessage.InviteLinkGroupType\022&\n\036inviteL"
+  "inkParentGroupSubjectV2\030\033 \001(\t\022(\n inviteL"
+  "inkParentGroupThumbnailV2\030\034 \001(\014\022U\n\025invit"
+  "eLinkGroupTypeV2\030\035 \001(\01626.proto.Message.E"
+  "xtendedTextMessage.InviteLinkGroupType\"v"
+  "\n\010FontType\022\016\n\nSANS_SERIF\020\000\022\t\n\005SERIF\020\001\022\023\n"
+  "\017NORICAN_REGULAR\020\002\022\021\n\rBRYNDAN_WRITE\020\003\022\025\n"
+  "\021BEBASNEUE_REGULAR\020\004\022\020\n\014OSWALD_HEAVY\020\005\"H"
+  "\n\023InviteLinkGroupType\022\013\n\007DEFAULT\020\000\022\n\n\006PA"
+  "RENT\020\001\022\007\n\003SUB\020\002\022\017\n\013DEFAULT_SUB\020\003\"\"\n\013Prev"
+  "iewType\022\010\n\004NONE\020\000\022\t\n\005VIDEO\020\001\0325\n\022FuturePr"
+  "oofMessage\022\037\n\007message\030\001 \001(\0132\016.proto.Mess"
+  "age\032\236\002\n\022GroupInviteMessage\022\020\n\010groupJid\030\001"
+  " \001(\t\022\022\n\ninviteCode\030\002 \001(\t\022\030\n\020inviteExpira"
+  "tion\030\003 \001(\003\022\021\n\tgroupName\030\004 \001(\t\022\025\n\rjpegThu"
+  "mbnail\030\005 \001(\014\022\017\n\007caption\030\006 \001(\t\022\'\n\013context"
+  "Info\030\007 \001(\0132\022.proto.ContextInfo\022>\n\tgroupT"
+  "ype\030\010 \001(\0162+.proto.Message.GroupInviteMes"
+  "sage.GroupType\"$\n\tGroupType\022\013\n\007DEFAULT\020\000"
+  "\022\n\n\006PARENT\020\001\032\257\013\n\027HighlyStructuredMessage"
+  "\022\021\n\tnamespace\030\001 \001(\t\022\023\n\013elementName\030\002 \001(\t"
+  "\022\016\n\006params\030\003 \003(\t\022\022\n\nfallbackLg\030\004 \001(\t\022\022\n\n"
+  "fallbackLc\030\005 \001(\t\022Y\n\021localizableParams\030\006 "
+  "\003(\0132>.proto.Message.HighlyStructuredMess"
+  "age.HSMLocalizableParameter\022\027\n\017determini"
+  "sticLg\030\007 \001(\t\022\027\n\017deterministicLc\030\010 \001(\t\0223\n"
+  "\013hydratedHsm\030\t \001(\0132\036.proto.Message.Templ"
+  "ateMessage\032\361\010\n\027HSMLocalizableParameter\022\017"
+  "\n\007default\030\001 \001(\t\022^\n\010currency\030\002 \001(\0132J.prot"
+  "o.Message.HighlyStructuredMessage.HSMLoc"
+  "alizableParameter.HSMCurrencyH\000\022^\n\010dateT"
+  "ime\030\003 \001(\0132J.proto.Message.HighlyStructur"
+  "edMessage.HSMLocalizableParameter.HSMDat"
+  "eTimeH\000\0327\n\013HSMCurrency\022\024\n\014currencyCode\030\001"
+  " \001(\t\022\022\n\namount1000\030\002 \001(\003\032\275\006\n\013HSMDateTime"
+  "\022t\n\tcomponent\030\001 \001(\0132_.proto.Message.High"
+  "lyStructuredMessage.HSMLocalizableParame"
+  "ter.HSMDateTime.HSMDateTimeComponentH\000\022t"
+  "\n\tunixEpoch\030\002 \001(\0132_.proto.Message.Highly"
+  "StructuredMessage.HSMLocalizableParamete"
+  "r.HSMDateTime.HSMDateTimeUnixEpochH\000\032\205\004\n"
+  "\024HSMDateTimeComponent\022\200\001\n\tdayOfWeek\030\001 \001("
+  "\0162m.proto.Message.HighlyStructuredMessag"
+  "e.HSMLocalizableParameter.HSMDateTime.HS"
+  "MDateTimeComponent.DayOfWeekType\022\014\n\004year"
+  "\030\002 \001(\r\022\r\n\005month\030\003 \001(\r\022\022\n\ndayOfMonth\030\004 \001("
+  "\r\022\014\n\004hour\030\005 \001(\r\022\016\n\006minute\030\006 \001(\r\022~\n\010calen"
+  "dar\030\007 \001(\0162l.proto.Message.HighlyStructur"
+  "edMessage.HSMLocalizableParameter.HSMDat"
+  "eTime.HSMDateTimeComponent.CalendarType\""
+  ".\n\014CalendarType\022\r\n\tGREGORIAN\020\001\022\017\n\013SOLAR_"
+  "HIJRI\020\002\"k\n\rDayOfWeekType\022\n\n\006MONDAY\020\001\022\013\n\007"
+  "TUESDAY\020\002\022\r\n\tWEDNESDAY\020\003\022\014\n\010THURSDAY\020\004\022\n"
+  "\n\006FRIDAY\020\005\022\014\n\010SATURDAY\020\006\022\n\n\006SUNDAY\020\007\032)\n\024"
+  "HSMDateTimeUnixEpoch\022\021\n\ttimestamp\030\001 \001(\003B"
+  "\017\n\rdatetimeOneofB\014\n\nparamOneof\032\357\002\n\027Histo"
+  "rySyncNotification\022\022\n\nfileSha256\030\001 \001(\014\022\022"
+  "\n\nfileLength\030\002 \001(\004\022\020\n\010mediaKey\030\003 \001(\014\022\025\n\r"
+  "fileEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\022"
+  "H\n\010syncType\030\006 \001(\01626.proto.Message.Histor"
+  "ySyncNotification.HistorySyncType\022\022\n\nchu"
+  "nkOrder\030\007 \001(\r\022\031\n\021originalMessageId\030\010 \001(\t"
+  "\022\020\n\010progress\030\t \001(\r\"d\n\017HistorySyncType\022\025\n"
+  "\021INITIAL_BOOTSTRAP\020\000\022\025\n\021INITIAL_STATUS_V"
+  "3\020\001\022\010\n\004FULL\020\002\022\n\n\006RECENT\020\003\022\r\n\tPUSH_NAME\020\004"
+  "\032\212\005\n\014ImageMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimety"
+  "pe\030\002 \001(\t\022\017\n\007caption\030\003 \001(\t\022\022\n\nfileSha256\030"
+  "\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\016\n\006height\030\006 \001("
+  "\r\022\r\n\005width\030\007 \001(\r\022\020\n\010mediaKey\030\010 \001(\014\022\025\n\rfi"
+  "leEncSha256\030\t \001(\014\022<\n\026interactiveAnnotati"
+  "ons\030\n \003(\0132\034.proto.InteractiveAnnotation\022"
+  "\022\n\ndirectPath\030\013 \001(\t\022\031\n\021mediaKeyTimestamp"
+  "\030\014 \001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013context"
+  "Info\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020firstS"
+  "canSidecar\030\022 \001(\014\022\027\n\017firstScanLength\030\023 \001("
+  "\r\022\031\n\021experimentGroupId\030\024 \001(\r\022\024\n\014scansSid"
+  "ecar\030\025 \001(\014\022\023\n\013scanLengths\030\026 \003(\r\022\034\n\024midQu"
+  "alityFileSha256\030\027 \001(\014\022\037\n\027midQualityFileE"
+  "ncSha256\030\030 \001(\014\022\020\n\010viewOnce\030\031 \001(\010\022\033\n\023thum"
+  "bnailDirectPath\030\032 \001(\t\022\027\n\017thumbnailSha256"
+  "\030\033 \001(\014\022\032\n\022thumbnailEncSha256\030\034 \001(\014\022\021\n\tst"
+  "aticUrl\030\035 \001(\t\032M\n&InitialSecurityNotifica"
+  "tionSettingSync\022#\n\033securityNotificationE"
+  "nabled\030\001 \001(\010\032\207\n\n\022InteractiveMessage\0228\n\006h"
+  "eader\030\001 \001(\0132(.proto.Message.InteractiveM"
+  "essage.Header\0224\n\004body\030\002 \001(\0132&.proto.Mess"
+  "age.InteractiveMessage.Body\0228\n\006footer\030\003 "
+  "\001(\0132(.proto.Message.InteractiveMessage.F"
+  "ooter\022\'\n\013contextInfo\030\017 \001(\0132\022.proto.Conte"
+  "xtInfo\022N\n\025shopStorefrontMessage\030\004 \001(\0132-."
+  "proto.Message.InteractiveMessage.ShopMes"
+  "sageH\000\022P\n\021collectionMessage\030\005 \001(\01323.prot"
+  "o.Message.InteractiveMessage.CollectionM"
+  "essageH\000\022P\n\021nativeFlowMessage\030\006 \001(\01323.pr"
+  "oto.Message.InteractiveMessage.NativeFlo"
+  "wMessageH\000\032\024\n\004Body\022\014\n\004text\030\001 \001(\t\032G\n\021Coll"
+  "ectionMessage\022\016\n\006bizJid\030\001 \001(\t\022\n\n\002id\030\002 \001("
+  "\t\022\026\n\016messageVersion\030\003 \001(\005\032\026\n\006Footer\022\014\n\004t"
+  "ext\030\001 \001(\t\032\214\002\n\006Header\022\r\n\005title\030\001 \001(\t\022\020\n\010s"
+  "ubtitle\030\002 \001(\t\022\032\n\022hasMediaAttachment\030\005 \001("
+  "\010\0229\n\017documentMessage\030\003 \001(\0132\036.proto.Messa"
+  "ge.DocumentMessageH\000\0223\n\014imageMessage\030\004 \001"
+  "(\0132\033.proto.Message.ImageMessageH\000\022\027\n\rjpe"
+  "gThumbnail\030\006 \001(\014H\000\0223\n\014videoMessage\030\007 \001(\013"
+  "2\033.proto.Message.VideoMessageH\000B\007\n\005media"
+  "\032\331\001\n\021NativeFlowMessage\022U\n\007buttons\030\001 \003(\0132"
+  "D.proto.Message.InteractiveMessage.Nativ"
+  "eFlowMessage.NativeFlowButton\022\031\n\021message"
+  "ParamsJson\030\002 \001(\t\022\026\n\016messageVersion\030\003 \001(\005"
+  "\032:\n\020NativeFlowButton\022\014\n\004name\030\001 \001(\t\022\030\n\020bu"
+  "ttonParamsJson\030\002 \001(\t\032\261\001\n\013ShopMessage\022\n\n\002"
+  "id\030\001 \001(\t\022F\n\007surface\030\002 \001(\01625.proto.Messag"
+  "e.InteractiveMessage.ShopMessage.Surface"
+  "\022\026\n\016messageVersion\030\003 \001(\005\"6\n\007Surface\022\023\n\017U"
+  "NKNOWN_SURFACE\020\000\022\006\n\002FB\020\001\022\006\n\002IG\020\002\022\006\n\002WA\020\003"
+  "B\024\n\022interactiveMessage\032\361\002\n\032InteractiveRe"
+  "sponseMessage\022<\n\004body\030\001 \001(\0132..proto.Mess"
+  "age.InteractiveResponseMessage.Body\022\'\n\013c"
+  "ontextInfo\030\017 \001(\0132\022.proto.ContextInfo\022h\n\031"
+  "nativeFlowResponseMessage\030\002 \001(\0132C.proto."
+  "Message.InteractiveResponseMessage.Nativ"
+  "eFlowResponseMessageH\000\032\024\n\004Body\022\014\n\004text\030\001"
+  " \001(\t\032N\n\031NativeFlowResponseMessage\022\014\n\004nam"
+  "e\030\001 \001(\t\022\022\n\nparamsJson\030\002 \001(\t\022\017\n\007version\030\003"
+  " \001(\005B\034\n\032interactiveResponseMessage\032\364\002\n\016I"
+  "nvoiceMessage\022\014\n\004note\030\001 \001(\t\022\r\n\005token\030\002 \001"
+  "(\t\022D\n\016attachmentType\030\003 \001(\0162,.proto.Messa"
+  "ge.InvoiceMessage.AttachmentType\022\032\n\022atta"
+  "chmentMimetype\030\004 \001(\t\022\032\n\022attachmentMediaK"
+  "ey\030\005 \001(\014\022#\n\033attachmentMediaKeyTimestamp\030"
+  "\006 \001(\003\022\034\n\024attachmentFileSha256\030\007 \001(\014\022\037\n\027a"
+  "ttachmentFileEncSha256\030\010 \001(\014\022\034\n\024attachme"
+  "ntDirectPath\030\t \001(\t\022\037\n\027attachmentJpegThum"
+  "bnail\030\n \001(\014\"$\n\016AttachmentType\022\t\n\005IMAGE\020\000"
+  "\022\007\n\003PDF\020\001\032k\n\021KeepInChatMessage\022\036\n\003key\030\001 "
+  "\001(\0132\021.proto.MessageKey\022!\n\010keepType\030\002 \001(\016"
+  "2\017.proto.KeepType\022\023\n\013timestampMs\030\003 \001(\003\032\347"
+  "\006\n\013ListMessage\022\r\n\005title\030\001 \001(\t\022\023\n\013descrip"
+  "tion\030\002 \001(\t\022\022\n\nbuttonText\030\003 \001(\t\0225\n\010listTy"
+  "pe\030\004 \001(\0162#.proto.Message.ListMessage.Lis"
+  "tType\0224\n\010sections\030\005 \003(\0132\".proto.Message."
+  "ListMessage.Section\022C\n\017productListInfo\030\006"
+  " \001(\0132*.proto.Message.ListMessage.Product"
+  "ListInfo\022\022\n\nfooterText\030\007 \001(\t\022\'\n\013contextI"
+  "nfo\030\010 \001(\0132\022.proto.ContextInfo\032B\n\026Product"
+  "ListHeaderImage\022\021\n\tproductId\030\001 \001(\t\022\025\n\rjp"
+  "egThumbnail\030\002 \001(\014\032\267\001\n\017ProductListInfo\022B\n"
+  "\017productSections\030\001 \003(\0132).proto.Message.L"
+  "istMessage.ProductSection\022F\n\013headerImage"
+  "\030\002 \001(\01321.proto.Message.ListMessage.Produ"
+  "ctListHeaderImage\022\030\n\020businessOwnerJid\030\003 "
+  "\001(\t\032U\n\016ProductSection\022\r\n\005title\030\001 \001(\t\0224\n\010"
+  "products\030\002 \003(\0132\".proto.Message.ListMessa"
+  "ge.Product\032\034\n\007Product\022\021\n\tproductId\030\001 \001(\t"
+  "\0328\n\003Row\022\r\n\005title\030\001 \001(\t\022\023\n\013description\030\002 "
+  "\001(\t\022\r\n\005rowId\030\003 \001(\t\032F\n\007Section\022\r\n\005title\030\001"
+  " \001(\t\022,\n\004rows\030\002 \003(\0132\036.proto.Message.ListM"
+  "essage.Row\"<\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rS"
+  "INGLE_SELECT\020\001\022\020\n\014PRODUCT_LIST\020\002\032\312\002\n\023Lis"
+  "tResponseMessage\022\r\n\005title\030\001 \001(\t\022=\n\010listT"
+  "ype\030\002 \001(\0162+.proto.Message.ListResponseMe"
+  "ssage.ListType\022O\n\021singleSelectReply\030\003 \001("
+  "\01324.proto.Message.ListResponseMessage.Si"
+  "ngleSelectReply\022\'\n\013contextInfo\030\004 \001(\0132\022.p"
+  "roto.ContextInfo\022\023\n\013description\030\005 \001(\t\032*\n"
+  "\021SingleSelectReply\022\025\n\rselectedRowId\030\001 \001("
+  "\t\"*\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rSINGLE_SEL"
+  "ECT\020\001\032\236\002\n\023LiveLocationMessage\022\027\n\017degrees"
+  "Latitude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001"
+  "\022\030\n\020accuracyInMeters\030\003 \001(\r\022\022\n\nspeedInMps"
+  "\030\004 \001(\002\022)\n!degreesClockwiseFromMagneticNo"
+  "rth\030\005 \001(\r\022\017\n\007caption\030\006 \001(\t\022\026\n\016sequenceNu"
+  "mber\030\007 \001(\003\022\022\n\ntimeOffset\030\010 \001(\r\022\025\n\rjpegTh"
+  "umbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.pro"
+  "to.ContextInfo\032\252\002\n\017LocationMessage\022\027\n\017de"
+  "greesLatitude\030\001 \001(\001\022\030\n\020degreesLongitude\030"
+  "\002 \001(\001\022\014\n\004name\030\003 \001(\t\022\017\n\007address\030\004 \001(\t\022\013\n\003"
+  "url\030\005 \001(\t\022\016\n\006isLive\030\006 \001(\010\022\030\n\020accuracyInM"
+  "eters\030\007 \001(\r\022\022\n\nspeedInMps\030\010 \001(\002\022)\n!degre"
+  "esClockwiseFromMagneticNorth\030\t \001(\r\022\017\n\007co"
+  "mment\030\013 \001(\t\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013co"
+  "ntextInfo\030\021 \001(\0132\022.proto.ContextInfo\032\226\003\n\014"
+  "OrderMessage\022\017\n\007orderId\030\001 \001(\t\022\021\n\tthumbna"
+  "il\030\002 \001(\014\022\021\n\titemCount\030\003 \001(\005\0227\n\006status\030\004 "
+  "\001(\0162\'.proto.Message.OrderMessage.OrderSt"
+  "atus\0229\n\007surface\030\005 \001(\0162(.proto.Message.Or"
+  "derMessage.OrderSurface\022\017\n\007message\030\006 \001(\t"
+  "\022\022\n\norderTitle\030\007 \001(\t\022\021\n\tsellerJid\030\010 \001(\t\022"
+  "\r\n\005token\030\t \001(\t\022\027\n\017totalAmount1000\030\n \001(\003\022"
+  "\031\n\021totalCurrencyCode\030\013 \001(\t\022\'\n\013contextInf"
+  "o\030\021 \001(\0132\022.proto.ContextInfo\"\032\n\013OrderStat"
+  "us\022\013\n\007INQUIRY\020\001\"\033\n\014OrderSurface\022\013\n\007CATAL"
+  "OG\020\001\032\257\001\n\024PaymentInviteMessage\022D\n\013service"
+  "Type\030\001 \001(\0162/.proto.Message.PaymentInvite"
+  "Message.ServiceType\022\027\n\017expiryTimestamp\030\002"
+  " \001(\003\"8\n\013ServiceType\022\013\n\007UNKNOWN\020\000\022\t\n\005FBPA"
+  "Y\020\001\022\010\n\004NOVI\020\002\022\007\n\003UPI\020\003\032\326\001\n\023PollCreationM"
+  "essage\022\016\n\006encKey\030\001 \001(\014\022\014\n\004name\030\002 \001(\t\022:\n\007"
+  "options\030\003 \003(\0132).proto.Message.PollCreati"
+  "onMessage.Option\022\036\n\026selectableOptionsCou"
+  "nt\030\004 \001(\r\022\'\n\013contextInfo\030\005 \001(\0132\022.proto.Co"
+  "ntextInfo\032\034\n\006Option\022\022\n\noptionName\030\001 \001(\t\032"
+  "1\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005e"
+  "ncIv\030\002 \001(\014\032\033\n\031PollUpdateMessageMetadata\032"
+  "\310\001\n\021PollUpdateMessage\0221\n\026pollCreationMes"
+  "sageKey\030\001 \001(\0132\021.proto.MessageKey\022)\n\004vote"
+  "\030\002 \001(\0132\033.proto.Message.PollEncValue\022:\n\010m"
+  "etadata\030\003 \001(\0132(.proto.Message.PollUpdate"
+  "MessageMetadata\022\031\n\021senderTimestampMs\030\004 \001"
+  "(\003\032*\n\017PollVoteMessage\022\027\n\017selectedOptions"
+  "\030\001 \003(\014\032\367\004\n\016ProductMessage\022>\n\007product\030\001 \001"
+  "(\0132-.proto.Message.ProductMessage.Produc"
+  "tSnapshot\022\030\n\020businessOwnerJid\030\002 \001(\t\022>\n\007c"
+  "atalog\030\004 \001(\0132-.proto.Message.ProductMess"
+  "age.CatalogSnapshot\022\014\n\004body\030\005 \001(\t\022\016\n\006foo"
+  "ter\030\006 \001(\t\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C"
+  "ontextInfo\032h\n\017CatalogSnapshot\0221\n\014catalog"
+  "Image\030\001 \001(\0132\033.proto.Message.ImageMessage"
+  "\022\r\n\005title\030\002 \001(\t\022\023\n\013description\030\003 \001(\t\032\231\002\n"
+  "\017ProductSnapshot\0221\n\014productImage\030\001 \001(\0132\033"
+  ".proto.Message.ImageMessage\022\021\n\tproductId"
+  "\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\023\n\013description\030\004 \001"
+  "(\t\022\024\n\014currencyCode\030\005 \001(\t\022\027\n\017priceAmount1"
+  "000\030\006 \001(\003\022\022\n\nretailerId\030\007 \001(\t\022\013\n\003url\030\010 \001"
+  "(\t\022\031\n\021productImageCount\030\t \001(\r\022\024\n\014firstIm"
+  "ageId\030\013 \001(\t\022\033\n\023salePriceAmount1000\030\014 \001(\003"
+  "\032\242\t\n\017ProtocolMessage\022\036\n\003key\030\001 \001(\0132\021.prot"
+  "o.MessageKey\0221\n\004type\030\002 \001(\0162#.proto.Messa"
+  "ge.ProtocolMessage.Type\022\033\n\023ephemeralExpi"
+  "ration\030\004 \001(\r\022!\n\031ephemeralSettingTimestam"
+  "p\030\005 \001(\003\022G\n\027historySyncNotification\030\006 \001(\013"
+  "2&.proto.Message.HistorySyncNotification"
+  "\022A\n\024appStateSyncKeyShare\030\007 \001(\0132#.proto.M"
+  "essage.AppStateSyncKeyShare\022E\n\026appStateS"
+  "yncKeyRequest\030\010 \001(\0132%.proto.Message.AppS"
+  "tateSyncKeyRequest\022e\n&initialSecurityNot"
+  "ificationSettingSync\030\t \001(\01325.proto.Messa"
+  "ge.InitialSecurityNotificationSettingSyn"
+  "c\022]\n\"appStateFatalExceptionNotification\030"
+  "\n \001(\01321.proto.Message.AppStateFatalExcep"
+  "tionNotification\0221\n\020disappearingMode\030\013 \001"
+  "(\0132\027.proto.DisappearingMode\022K\n\031requestMe"
+  "diaUploadMessage\030\014 \001(\0132(.proto.Message.R"
+  "equestMediaUploadMessage\022[\n!requestMedia"
+  "UploadResponseMessage\030\r \001(\01320.proto.Mess"
+  "age.RequestMediaUploadResponseMessage\"\205\003"
+  "\n\004Type\022\n\n\006REVOKE\020\000\022\025\n\021EPHEMERAL_SETTING\020"
+  "\003\022\033\n\027EPHEMERAL_SYNC_RESPONSE\020\004\022\035\n\031HISTOR"
+  "Y_SYNC_NOTIFICATION\020\005\022\034\n\030APP_STATE_SYNC_"
+  "KEY_SHARE\020\006\022\036\n\032APP_STATE_SYNC_KEY_REQUES"
+  "T\020\007\022\037\n\033MSG_FANOUT_BACKFILL_REQUEST\020\010\022.\n*"
+  "INITIAL_SECURITY_NOTIFICATION_SETTING_SY"
+  "NC\020\t\022*\n&APP_STATE_FATAL_EXCEPTION_NOTIFI"
+  "CATION\020\n\022\026\n\022SHARE_PHONE_NUMBER\020\013\022 \n\034REQU"
+  "EST_MEDIA_UPLOAD_MESSAGE\020\014\022)\n%REQUEST_ME"
+  "DIA_UPLOAD_RESPONSE_MESSAGE\020\r\032o\n\017Reactio"
+  "nMessage\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey"
+  "\022\014\n\004text\030\002 \001(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021s"
+  "enderTimestampMs\030\004 \001(\003\032\\\n\031RequestMediaUp"
+  "loadMessage\022\022\n\nfileSha256\030\001 \003(\t\022+\n\trmrSo"
+  "urce\030\002 \001(\0162\030.proto.Message.RmrSource\032\362\002\n"
+  "!RequestMediaUploadResponseMessage\022+\n\trm"
+  "rSource\030\001 \001(\0162\030.proto.Message.RmrSource\022"
+  "\020\n\010stanzaId\030\002 \001(\t\022a\n\016reuploadResult\030\003 \003("
+  "\0132I.proto.Message.RequestMediaUploadResp"
+  "onseMessage.RequestMediaUploadResult\032\252\001\n"
+  "\030RequestMediaUploadResult\022\022\n\nfileSha256\030"
+  "\001 \001(\t\022C\n\021mediaUploadResult\030\002 \001(\0162(.proto"
+  ".MediaRetryNotification.ResultType\0225\n\016st"
+  "ickerMessage\030\003 \001(\0132\035.proto.Message.Stick"
+  "erMessage\032\347\001\n\025RequestPaymentMessage\022#\n\013n"
+  "oteMessage\030\004 \001(\0132\016.proto.Message\022\033\n\023curr"
+  "encyCodeIso4217\030\001 \001(\t\022\022\n\namount1000\030\002 \001("
+  "\004\022\023\n\013requestFrom\030\003 \001(\t\022\027\n\017expiryTimestam"
+  "p\030\005 \001(\003\022\034\n\006amount\030\006 \001(\0132\014.proto.Money\022,\n"
+  "\nbackground\030\007 \001(\0132\030.proto.PaymentBackgro"
+  "und\032D\n\031RequestPhoneNumberMessage\022\'\n\013cont"
+  "extInfo\030\001 \001(\0132\022.proto.ContextInfo\032\225\001\n\022Se"
+  "ndPaymentMessage\022#\n\013noteMessage\030\002 \001(\0132\016."
+  "proto.Message\022,\n\021requestMessageKey\030\003 \001(\013"
+  "2\021.proto.MessageKey\022,\n\nbackground\030\004 \001(\0132"
+  "\030.proto.PaymentBackground\032\\\n\034SenderKeyDi"
+  "stributionMessage\022\017\n\007groupId\030\001 \001(\t\022+\n#ax"
+  "olotlSenderKeyDistributionMessage\030\002 \001(\014\032"
+  "\326\002\n\016StickerMessage\022\013\n\003url\030\001 \001(\t\022\022\n\nfileS"
+  "ha256\030\002 \001(\014\022\025\n\rfileEncSha256\030\003 \001(\014\022\020\n\010me"
+  "diaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001(\t\022\016\n\006height"
+  "\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndirectPath\030\010 \001("
+  "\t\022\022\n\nfileLength\030\t \001(\004\022\031\n\021mediaKeyTimesta"
+  "mp\030\n \001(\003\022\030\n\020firstFrameLength\030\013 \001(\r\022\031\n\021fi"
+  "rstFrameSidecar\030\014 \001(\014\022\022\n\nisAnimated\030\r \001("
+  "\010\022\024\n\014pngThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021"
+  " \001(\0132\022.proto.ContextInfo\032V\n\025StickerSyncR"
+  "MRMessage\022\020\n\010filehash\030\001 \003(\t\022\021\n\trmrSource"
+  "\030\002 \001(\t\022\030\n\020requestTimestamp\030\003 \001(\003\032\215\001\n\032Tem"
+  "plateButtonReplyMessage\022\022\n\nselectedId\030\001 "
+  "\001(\t\022\033\n\023selectedDisplayText\030\002 \001(\t\022\'\n\013cont"
+  "extInfo\030\003 \001(\0132\022.proto.ContextInfo\022\025\n\rsel"
+  "ectedIndex\030\004 \001(\r\032\304\t\n\017TemplateMessage\022\'\n\013"
+  "contextInfo\030\003 \001(\0132\022.proto.ContextInfo\022P\n"
+  "\020hydratedTemplate\030\004 \001(\01326.proto.Message."
+  "TemplateMessage.HydratedFourRowTemplate\022"
+  "I\n\017fourRowTemplate\030\001 \001(\0132..proto.Message"
+  ".TemplateMessage.FourRowTemplateH\000\022Y\n\027hy"
+  "dratedFourRowTemplate\030\002 \001(\01326.proto.Mess"
+  "age.TemplateMessage.HydratedFourRowTempl"
+  "ateH\000\032\336\003\n\017FourRowTemplate\0227\n\007content\030\006 \001"
+  "(\0132&.proto.Message.HighlyStructuredMessa"
+  "ge\0226\n\006footer\030\007 \001(\0132&.proto.Message.Highl"
+  "yStructuredMessage\022&\n\007buttons\030\010 \003(\0132\025.pr"
+  "oto.TemplateButton\0229\n\017documentMessage\030\001 "
+  "\001(\0132\036.proto.Message.DocumentMessageH\000\022I\n"
+  "\027highlyStructuredMessage\030\002 \001(\0132&.proto.M"
+  "essage.HighlyStructuredMessageH\000\0223\n\014imag"
+  "eMessage\030\003 \001(\0132\033.proto.Message.ImageMess"
+  "ageH\000\0223\n\014videoMessage\030\004 \001(\0132\033.proto.Mess"
+  "age.VideoMessageH\000\0229\n\017locationMessage\030\005 "
+  "\001(\0132\036.proto.Message.LocationMessageH\000B\007\n"
+  "\005title\032\244\003\n\027HydratedFourRowTemplate\022\033\n\023hy"
+  "dratedContentText\030\006 \001(\t\022\032\n\022hydratedFoote"
+  "rText\030\007 \001(\t\0226\n\017hydratedButtons\030\010 \003(\0132\035.p"
+  "roto.HydratedTemplateButton\022\022\n\ntemplateI"
+  "d\030\t \001(\t\0229\n\017documentMessage\030\001 \001(\0132\036.proto"
+  ".Message.DocumentMessageH\000\022\033\n\021hydratedTi"
+  "tleText\030\002 \001(\tH\000\0223\n\014imageMessage\030\003 \001(\0132\033."
+  "proto.Message.ImageMessageH\000\0223\n\014videoMes"
+  "sage\030\004 \001(\0132\033.proto.Message.VideoMessageH"
+  "\000\0229\n\017locationMessage\030\005 \001(\0132\036.proto.Messa"
+  "ge.LocationMessageH\000B\007\n\005titleB\010\n\006format\032"
+  "\202\005\n\014VideoMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetyp"
+  "e\030\002 \001(\t\022\022\n\nfileSha256\030\003 \001(\014\022\022\n\nfileLengt"
+  "h\030\004 \001(\004\022\017\n\007seconds\030\005 \001(\r\022\020\n\010mediaKey\030\006 \001"
+  "(\014\022\017\n\007caption\030\007 \001(\t\022\023\n\013gifPlayback\030\010 \001(\010"
+  "\022\016\n\006height\030\t \001(\r\022\r\n\005width\030\n \001(\r\022\025\n\rfileE"
+  "ncSha256\030\013 \001(\014\022<\n\026interactiveAnnotations"
+  "\030\014 \003(\0132\034.proto.InteractiveAnnotation\022\022\n\n"
+  "directPath\030\r \001(\t\022\031\n\021mediaKeyTimestamp\030\016 "
+  "\001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInf"
+  "o\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020streaming"
+  "Sidecar\030\022 \001(\014\022\?\n\016gifAttribution\030\023 \001(\0162\'."
+  "proto.Message.VideoMessage.Attribution\022\020"
+  "\n\010viewOnce\030\024 \001(\010\022\033\n\023thumbnailDirectPath\030"
+  "\025 \001(\t\022\027\n\017thumbnailSha256\030\026 \001(\014\022\032\n\022thumbn"
+  "ailEncSha256\030\027 \001(\014\022\021\n\tstaticUrl\030\030 \001(\t\"-\n"
+  "\013Attribution\022\010\n\004NONE\020\000\022\t\n\005GIPHY\020\001\022\t\n\005TEN"
+  "OR\020\002\"5\n\tRmrSource\022\024\n\020FAVORITE_STICKER\020\000\022"
+  "\022\n\016RECENT_STICKER\020\001\"\233\001\n\022MessageContextIn"
+  "fo\0225\n\022deviceListMetadata\030\001 \001(\0132\031.proto.D"
+  "eviceListMetadata\022!\n\031deviceListMetadataV"
+  "ersion\030\002 \001(\005\022\025\n\rmessageSecret\030\003 \001(\014\022\024\n\014p"
+  "addingBytes\030\004 \001(\014\"P\n\nMessageKey\022\021\n\tremot"
+  "eJid\030\001 \001(\t\022\016\n\006fromMe\030\002 \001(\010\022\n\n\002id\030\003 \001(\t\022\023"
+  "\n\013participant\030\004 \001(\t\"<\n\005Money\022\r\n\005value\030\001 "
+  "\001(\003\022\016\n\006offset\030\002 \001(\r\022\024\n\014currencyCode\030\003 \001("
+  "\t\"\232\004\n\rMsgOpaqueData\022\014\n\004body\030\001 \001(\t\022\017\n\007cap"
+  "tion\030\003 \001(\t\022\013\n\003lng\030\005 \001(\001\022\016\n\006isLive\030\006 \001(\010\022"
+  "\013\n\003lat\030\007 \001(\001\022\031\n\021paymentAmount1000\030\010 \001(\005\022"
+  "\032\n\022paymentNoteMsgBody\030\t \001(\t\022\024\n\014canonical"
+  "Url\030\n \001(\t\022\023\n\013matchedText\030\013 \001(\t\022\r\n\005title\030"
+  "\014 \001(\t\022\023\n\013description\030\r \001(\t\022\031\n\021futureproo"
+  "fBuffer\030\016 \001(\014\022\021\n\tclientUrl\030\017 \001(\t\022\013\n\003loc\030"
+  "\020 \001(\t\022\020\n\010pollName\030\021 \001(\t\0224\n\013pollOptions\030\022"
+  " \003(\0132\037.proto.MsgOpaqueData.PollOption\022\"\n"
+  "\032pollSelectableOptionsCount\030\024 \001(\r\022\025\n\rmes"
+  "sageSecret\030\025 \001(\014\022\031\n\021senderTimestampMs\030\026 "
+  "\001(\003\022\033\n\023pollUpdateParentKey\030\027 \001(\t\022(\n\013encP"
+  "ollVote\030\030 \001(\0132\023.proto.PollEncValue\032\032\n\nPo"
+  "llOption\022\014\n\004name\030\001 \001(\t\"e\n\020MsgRowOpaqueDa"
+  "ta\022(\n\ncurrentMsg\030\001 \001(\0132\024.proto.MsgOpaque"
+  "Data\022\'\n\tquotedMsg\030\002 \001(\0132\024.proto.MsgOpaqu"
+  "eData\"\220\001\n\020NoiseCertificate\022\017\n\007details\030\001 "
+  "\001(\014\022\021\n\tsignature\030\002 \001(\014\032X\n\007Details\022\016\n\006ser"
+  "ial\030\001 \001(\r\022\016\n\006issuer\030\002 \001(\t\022\017\n\007expires\030\003 \001"
+  "(\004\022\017\n\007subject\030\004 \001(\t\022\013\n\003key\030\005 \001(\014\"\211\001\n\027Not"
+  "ificationMessageInfo\022\036\n\003key\030\001 \001(\0132\021.prot"
+  "o.MessageKey\022\037\n\007message\030\002 \001(\0132\016.proto.Me"
+  "ssage\022\030\n\020messageTimestamp\030\003 \001(\004\022\023\n\013parti"
+  "cipant\030\004 \001(\t\"\222\001\n\017PastParticipant\022\017\n\007user"
+  "Jid\030\001 \002(\t\0227\n\013leaveReason\030\002 \002(\0162\".proto.P"
+  "astParticipant.LeaveReason\022\017\n\007leaveTs\030\003 "
+  "\002(\004\"$\n\013LeaveReason\022\010\n\004LEFT\020\000\022\013\n\007REMOVED\020"
+  "\001\"V\n\020PastParticipants\022\020\n\010groupJid\030\001 \002(\t\022"
+  "0\n\020pastParticipants\030\002 \003(\0132\026.proto.PastPa"
+  "rticipant\"\243\003\n\021PaymentBackground\022\n\n\002id\030\001 "
+  "\001(\t\022\022\n\nfileLength\030\002 \001(\004\022\r\n\005width\030\003 \001(\r\022\016"
+  "\n\006height\030\004 \001(\r\022\020\n\010mimetype\030\005 \001(\t\022\027\n\017plac"
+  "eholderArgb\030\006 \001(\007\022\020\n\010textArgb\030\007 \001(\007\022\023\n\013s"
+  "ubtextArgb\030\010 \001(\007\0225\n\tmediaData\030\t \001(\0132\".pr"
+  "oto.PaymentBackground.MediaData\022+\n\004type\030"
+  "\n \001(\0162\035.proto.PaymentBackground.Type\032w\n\t"
+  "MediaData\022\020\n\010mediaKey\030\001 \001(\014\022\031\n\021mediaKeyT"
+  "imestamp\030\002 \001(\003\022\022\n\nfileSha256\030\003 \001(\014\022\025\n\rfi"
+  "leEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\" \n"
+  "\004Type\022\013\n\007UNKNOWN\020\000\022\013\n\007DEFAULT\020\001\"\325\n\n\013Paym"
+  "entInfo\0227\n\022currencyDeprecated\030\001 \001(\0162\033.pr"
+  "oto.PaymentInfo.Currency\022\022\n\namount1000\030\002"
+  " \001(\004\022\023\n\013receiverJid\030\003 \001(\t\022)\n\006status\030\004 \001("
+  "\0162\031.proto.PaymentInfo.Status\022\034\n\024transact"
+  "ionTimestamp\030\005 \001(\004\022,\n\021requestMessageKey\030"
+  "\006 \001(\0132\021.proto.MessageKey\022\027\n\017expiryTimest"
+  "amp\030\007 \001(\004\022\025\n\rfutureproofed\030\010 \001(\010\022\020\n\010curr"
+  "ency\030\t \001(\t\022/\n\ttxnStatus\030\n \001(\0162\034.proto.Pa"
+  "ymentInfo.TxnStatus\022\031\n\021useNoviFiatFormat"
+  "\030\013 \001(\010\022#\n\rprimaryAmount\030\014 \001(\0132\014.proto.Mo"
+  "ney\022$\n\016exchangeAmount\030\r \001(\0132\014.proto.Mone"
+  "y\")\n\010Currency\022\024\n\020UNKNOWN_CURRENCY\020\000\022\007\n\003I"
+  "NR\020\001\"\314\001\n\006Status\022\022\n\016UNKNOWN_STATUS\020\000\022\016\n\nP"
+  "ROCESSING\020\001\022\010\n\004SENT\020\002\022\022\n\016NEED_TO_ACCEPT\020"
+  "\003\022\014\n\010COMPLETE\020\004\022\026\n\022COULD_NOT_COMPLETE\020\005\022"
+  "\014\n\010REFUNDED\020\006\022\013\n\007EXPIRED\020\007\022\014\n\010REJECTED\020\010"
+  "\022\r\n\tCANCELLED\020\t\022\025\n\021WAITING_FOR_PAYER\020\n\022\013"
+  "\n\007WAITING\020\013\"\231\005\n\tTxnStatus\022\013\n\007UNKNOWN\020\000\022\021"
+  "\n\rPENDING_SETUP\020\001\022\032\n\026PENDING_RECEIVER_SE"
+  "TUP\020\002\022\010\n\004INIT\020\003\022\013\n\007SUCCESS\020\004\022\r\n\tCOMPLETE"
+  "D\020\005\022\n\n\006FAILED\020\006\022\017\n\013FAILED_RISK\020\007\022\025\n\021FAIL"
+  "ED_PROCESSING\020\010\022\036\n\032FAILED_RECEIVER_PROCE"
+  "SSING\020\t\022\r\n\tFAILED_DA\020\n\022\023\n\017FAILED_DA_FINA"
+  "L\020\013\022\020\n\014REFUNDED_TXN\020\014\022\021\n\rREFUND_FAILED\020\r"
+  "\022\034\n\030REFUND_FAILED_PROCESSING\020\016\022\024\n\020REFUND"
+  "_FAILED_DA\020\017\022\017\n\013EXPIRED_TXN\020\020\022\021\n\rAUTH_CA"
+  "NCELED\020\021\022!\n\035AUTH_CANCEL_FAILED_PROCESSIN"
+  "G\020\022\022\026\n\022AUTH_CANCEL_FAILED\020\023\022\020\n\014COLLECT_I"
+  "NIT\020\024\022\023\n\017COLLECT_SUCCESS\020\025\022\022\n\016COLLECT_FA"
+  "ILED\020\026\022\027\n\023COLLECT_FAILED_RISK\020\027\022\024\n\020COLLE"
+  "CT_REJECTED\020\030\022\023\n\017COLLECT_EXPIRED\020\031\022\024\n\020CO"
+  "LLECT_CANCELED\020\032\022\026\n\022COLLECT_CANCELLING\020\033"
+  "\022\r\n\tIN_REVIEW\020\034\022\024\n\020REVERSAL_SUCCESS\020\035\022\024\n"
+  "\020REVERSAL_PENDING\020\036\022\022\n\016REFUND_PENDING\020\037\""
+  "\315\001\n\022PendingKeyExchange\022\020\n\010sequence\030\001 \001(\r"
+  "\022\024\n\014localBaseKey\030\002 \001(\014\022\033\n\023localBaseKeyPr"
+  "ivate\030\003 \001(\014\022\027\n\017localRatchetKey\030\004 \001(\014\022\036\n\026"
+  "localRatchetKeyPrivate\030\005 \001(\014\022\030\n\020localIde"
+  "ntityKey\030\007 \001(\014\022\037\n\027localIdentityKeyPrivat"
+  "e\030\010 \001(\014\"J\n\rPendingPreKey\022\020\n\010preKeyId\030\001 \001"
+  "(\r\022\026\n\016signedPreKeyId\030\003 \001(\005\022\017\n\007baseKey\030\002 "
+  "\001(\014\"E\n\013PhotoChange\022\020\n\010oldPhoto\030\001 \001(\014\022\020\n\010"
+  "newPhoto\030\002 \001(\014\022\022\n\nnewPhotoId\030\003 \001(\r\"G\n\005Po"
+  "int\022\023\n\013xDeprecated\030\001 \001(\005\022\023\n\013yDeprecated\030"
+  "\002 \001(\005\022\t\n\001x\030\003 \001(\001\022\t\n\001y\030\004 \001(\001\"1\n\026PollAddit"
+  "ionalMetadata\022\027\n\017pollInvalidated\030\001 \001(\010\"1"
+  "\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005en"
+  "cIv\030\002 \001(\014\"\206\001\n\nPollUpdate\022/\n\024pollUpdateMe"
+  "ssageKey\030\001 \001(\0132\021.proto.MessageKey\022,\n\004vot"
+  "e\030\002 \001(\0132\036.proto.Message.PollVoteMessage\022"
+  "\031\n\021senderTimestampMs\030\003 \001(\003\"J\n\025PreKeyReco"
+  "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001"
+  "(\014\022\022\n\nprivateKey\030\003 \001(\014\"(\n\010Pushname\022\n\n\002id"
+  "\030\001 \001(\t\022\020\n\010pushname\030\002 \001(\t\"x\n\010Reaction\022\036\n\003"
+  "key\030\001 \001(\0132\021.proto.MessageKey\022\014\n\004text\030\002 \001"
+  "(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021senderTimesta"
+  "mpMs\030\004 \001(\003\022\016\n\006unread\030\005 \001(\010\"2\n\021RecentEmoj"
+  "iWeight\022\r\n\005emoji\030\001 \001(\t\022\016\n\006weight\030\002 \001(\002\"u"
+  "\n\017RecordStructure\022/\n\016currentSession\030\001 \001("
+  "\0132\027.proto.SessionStructure\0221\n\020previousSe"
+  "ssions\030\002 \003(\0132\027.proto.SessionStructure\"1\n"
+  "\016SenderChainKey\022\021\n\titeration\030\001 \001(\r\022\014\n\004se"
+  "ed\030\002 \001(\014\"S\n\030SenderKeyRecordStructure\0227\n\017"
+  "senderKeyStates\030\001 \003(\0132\036.proto.SenderKeyS"
+  "tateStructure\"\304\001\n\027SenderKeyStateStructur"
+  "e\022\023\n\013senderKeyId\030\001 \001(\r\022-\n\016senderChainKey"
+  "\030\002 \001(\0132\025.proto.SenderChainKey\0221\n\020senderS"
+  "igningKey\030\003 \001(\0132\027.proto.SenderSigningKey"
+  "\0222\n\021senderMessageKeys\030\004 \003(\0132\027.proto.Send"
+  "erMessageKey\"3\n\020SenderMessageKey\022\021\n\titer"
+  "ation\030\001 \001(\r\022\014\n\004seed\030\002 \001(\014\"3\n\020SenderSigni"
+  "ngKey\022\016\n\006public\030\001 \001(\014\022\017\n\007private\030\002 \001(\014\"&"
+  "\n\022ServerErrorReceipt\022\020\n\010stanzaId\030\001 \001(\t\"\243"
+  "\003\n\020SessionStructure\022\026\n\016sessionVersion\030\001 "
+  "\001(\r\022\033\n\023localIdentityPublic\030\002 \001(\014\022\034\n\024remo"
+  "teIdentityPublic\030\003 \001(\014\022\017\n\007rootKey\030\004 \001(\014\022"
+  "\027\n\017previousCounter\030\005 \001(\r\022!\n\013senderChain\030"
+  "\006 \001(\0132\014.proto.Chain\022$\n\016receiverChains\030\007 "
+  "\003(\0132\014.proto.Chain\0225\n\022pendingKeyExchange\030"
+  "\010 \001(\0132\031.proto.PendingKeyExchange\022+\n\rpend"
+  "ingPreKey\030\t \001(\0132\024.proto.PendingPreKey\022\034\n"
+  "\024remoteRegistrationId\030\n \001(\r\022\033\n\023localRegi"
+  "strationId\030\013 \001(\r\022\024\n\014needsRefresh\030\014 \001(\010\022\024"
+  "\n\014aliceBaseKey\030\r \001(\014\"v\n\033SignedPreKeyReco"
+  "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001"
+  "(\014\022\022\n\nprivateKey\030\003 \001(\014\022\021\n\tsignature\030\004 \001("
+  "\014\022\021\n\ttimestamp\030\005 \001(\006\"D\n\tStatusPSA\022\022\n\ncam"
+  "paignId\030, \002(\004\022#\n\033campaignExpirationTimes"
+  "tamp\030- \001(\004\"\304\001\n\017StickerMetadata\022\013\n\003url\030\001 "
+  "\001(\t\022\022\n\nfileSha256\030\002 \001(\014\022\025\n\rfileEncSha256"
+  "\030\003 \001(\014\022\020\n\010mediaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001"
+  "(\t\022\016\n\006height\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndir"
+  "ectPath\030\010 \001(\t\022\022\n\nfileLength\030\t \001(\004\022\016\n\006wei"
+  "ght\030\n \001(\002\"h\n\016SyncActionData\022\r\n\005index\030\001 \001"
+  "(\014\022%\n\005value\030\002 \001(\0132\026.proto.SyncActionValu"
+  "e\022\017\n\007padding\030\003 \001(\014\022\017\n\007version\030\004 \001(\005\"\235\036\n\017"
+  "SyncActionValue\022\021\n\ttimestamp\030\001 \001(\003\0225\n\nst"
+  "arAction\030\002 \001(\0132!.proto.SyncActionValue.S"
+  "tarAction\022;\n\rcontactAction\030\003 \001(\0132$.proto"
+  ".SyncActionValue.ContactAction\0225\n\nmuteAc"
+  "tion\030\004 \001(\0132!.proto.SyncActionValue.MuteA"
+  "ction\0223\n\tpinAction\030\005 \001(\0132 .proto.SyncAct"
+  "ionValue.PinAction\022W\n\033securityNotificati"
+  "onSetting\030\006 \001(\01322.proto.SyncActionValue."
+  "SecurityNotificationSetting\022\?\n\017pushNameS"
+  "etting\030\007 \001(\0132&.proto.SyncActionValue.Pus"
+  "hNameSetting\022A\n\020quickReplyAction\030\010 \001(\0132\'"
+  ".proto.SyncActionValue.QuickReplyAction\022"
+  "Q\n\030recentEmojiWeightsAction\030\013 \001(\0132/.prot"
+  "o.SyncActionValue.RecentEmojiWeightsActi"
+  "on\022\?\n\017labelEditAction\030\016 \001(\0132&.proto.Sync"
+  "ActionValue.LabelEditAction\022M\n\026labelAsso"
+  "ciationAction\030\017 \001(\0132-.proto.SyncActionVa"
+  "lue.LabelAssociationAction\022;\n\rlocaleSett"
+  "ing\030\020 \001(\0132$.proto.SyncActionValue.Locale"
+  "Setting\022C\n\021archiveChatAction\030\021 \001(\0132(.pro"
+  "to.SyncActionValue.ArchiveChatAction\022Q\n\030"
+  "deleteMessageForMeAction\030\022 \001(\0132/.proto.S"
+  "yncActionValue.DeleteMessageForMeAction\022"
+  ";\n\rkeyExpiration\030\023 \001(\0132$.proto.SyncActio"
+  "nValue.KeyExpiration\022I\n\024markChatAsReadAc"
+  "tion\030\024 \001(\0132+.proto.SyncActionValue.MarkC"
+  "hatAsReadAction\022\?\n\017clearChatAction\030\025 \001(\013"
+  "2&.proto.SyncActionValue.ClearChatAction"
+  "\022A\n\020deleteChatAction\030\026 \001(\0132\'.proto.SyncA"
+  "ctionValue.DeleteChatAction\022K\n\025unarchive"
+  "ChatsSetting\030\027 \001(\0132,.proto.SyncActionVal"
+  "ue.UnarchiveChatsSetting\022=\n\016primaryFeatu"
+  "re\030\030 \001(\0132%.proto.SyncActionValue.Primary"
+  "Feature\022S\n\031androidUnsupportedActions\030\032 \001"
+  "(\01320.proto.SyncActionValue.AndroidUnsupp"
+  "ortedActions\0227\n\013agentAction\030\033 \001(\0132\".prot"
+  "o.SyncActionValue.AgentAction\022E\n\022subscri"
+  "ptionAction\030\034 \001(\0132).proto.SyncActionValu"
+  "e.SubscriptionAction\022I\n\024userStatusMuteAc"
+  "tion\030\035 \001(\0132+.proto.SyncActionValue.UserS"
+  "tatusMuteAction\022A\n\020timeFormatAction\030\036 \001("
+  "\0132\'.proto.SyncActionValue.TimeFormatActi"
+  "on\0223\n\tnuxAction\030\037 \001(\0132 .proto.SyncAction"
+  "Value.NuxAction\022I\n\024primaryVersionAction\030"
+  "  \001(\0132+.proto.SyncActionValue.PrimaryVer"
+  "sionAction\022;\n\rstickerAction\030! \001(\0132$.prot"
+  "o.SyncActionValue.StickerAction\032@\n\013Agent"
+  "Action\022\014\n\004name\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\005\022\021"
+  "\n\tisDeleted\030\003 \001(\010\032,\n\031AndroidUnsupportedA"
+  "ctions\022\017\n\007allowed\030\001 \001(\010\032j\n\021ArchiveChatAc"
+  "tion\022\020\n\010archived\030\001 \001(\010\022C\n\014messageRange\030\002"
+  " \001(\0132-.proto.SyncActionValue.SyncActionM"
+  "essageRange\032V\n\017ClearChatAction\022C\n\014messag"
+  "eRange\030\001 \001(\0132-.proto.SyncActionValue.Syn"
+  "cActionMessageRange\0324\n\rContactAction\022\020\n\010"
+  "fullName\030\001 \001(\t\022\021\n\tfirstName\030\002 \001(\t\032W\n\020Del"
+  "eteChatAction\022C\n\014messageRange\030\001 \001(\0132-.pr"
+  "oto.SyncActionValue.SyncActionMessageRan"
+  "ge\032I\n\030DeleteMessageForMeAction\022\023\n\013delete"
+  "Media\030\001 \001(\010\022\030\n\020messageTimestamp\030\002 \001(\003\032(\n"
+  "\rKeyExpiration\022\027\n\017expiredKeyEpoch\030\001 \001(\005\032"
+  ")\n\026LabelAssociationAction\022\017\n\007labeled\030\001 \001"
+  "(\010\032U\n\017LabelEditAction\022\014\n\004name\030\001 \001(\t\022\r\n\005c"
+  "olor\030\002 \001(\005\022\024\n\014predefinedId\030\003 \001(\005\022\017\n\007dele"
+  "ted\030\004 \001(\010\032\037\n\rLocaleSetting\022\016\n\006locale\030\001 \001"
+  "(\t\032i\n\024MarkChatAsReadAction\022\014\n\004read\030\001 \001(\010"
+  "\022C\n\014messageRange\030\002 \001(\0132-.proto.SyncActio"
+  "nValue.SyncActionMessageRange\0325\n\nMuteAct"
+  "ion\022\r\n\005muted\030\001 \001(\010\022\030\n\020muteEndTimestamp\030\002"
+  " \001(\003\032!\n\tNuxAction\022\024\n\014acknowledged\030\001 \001(\010\032"
+  "\033\n\tPinAction\022\016\n\006pinned\030\001 \001(\010\032\037\n\016PrimaryF"
+  "eature\022\r\n\005flags\030\001 \003(\t\032\'\n\024PrimaryVersionA"
+  "ction\022\017\n\007version\030\001 \001(\t\032\037\n\017PushNameSettin"
+  "g\022\014\n\004name\030\001 \001(\t\032g\n\020QuickReplyAction\022\020\n\010s"
+  "hortcut\030\001 \001(\t\022\017\n\007message\030\002 \001(\t\022\020\n\010keywor"
+  "ds\030\003 \003(\t\022\r\n\005count\030\004 \001(\005\022\017\n\007deleted\030\005 \001(\010"
+  "\032E\n\030RecentEmojiWeightsAction\022)\n\007weights\030"
+  "\001 \003(\0132\030.proto.RecentEmojiWeight\0327\n\033Secur"
+  "ityNotificationSetting\022\030\n\020showNotificati"
+  "on\030\001 \001(\010\032\035\n\nStarAction\022\017\n\007starred\030\001 \001(\010\032"
+  "\310\001\n\rStickerAction\022\013\n\003url\030\001 \001(\t\022\025\n\rfileEn"
+  "cSha256\030\002 \001(\014\022\020\n\010mediaKey\030\003 \001(\014\022\020\n\010mimet"
+  "ype\030\004 \001(\t\022\016\n\006height\030\005 \001(\r\022\r\n\005width\030\006 \001(\r"
+  "\022\022\n\ndirectPath\030\007 \001(\t\022\022\n\nfileLength\030\010 \001(\004"
+  "\022\022\n\nisFavorite\030\t \001(\010\022\024\n\014deviceIdHint\030\n \001"
+  "(\r\032[\n\022SubscriptionAction\022\025\n\risDeactivate"
+  "d\030\001 \001(\010\022\026\n\016isAutoRenewing\030\002 \001(\010\022\026\n\016expir"
+  "ationDate\030\003 \001(\003\032\226\001\n\026SyncActionMessageRan"
+  "ge\022\034\n\024lastMessageTimestamp\030\001 \001(\003\022\"\n\032last"
+  "SystemMessageTimestamp\030\002 \001(\003\022:\n\010messages"
+  "\030\003 \003(\0132(.proto.SyncActionValue.SyncActio"
+  "nMessage\032F\n\021SyncActionMessage\022\036\n\003key\030\001 \001"
+  "(\0132\021.proto.MessageKey\022\021\n\ttimestamp\030\002 \001(\003"
+  "\0329\n\020TimeFormatAction\022%\n\035isTwentyFourHour"
+  "FormatEnabled\030\001 \001(\010\032/\n\025UnarchiveChatsSet"
+  "ting\022\026\n\016unarchiveChats\030\001 \001(\010\032%\n\024UserStat"
+  "usMuteAction\022\r\n\005muted\030\001 \001(\010\"\032\n\nSyncdInde"
+  "x\022\014\n\004blob\030\001 \001(\014\"\222\001\n\rSyncdMutation\0226\n\tope"
+  "ration\030\001 \001(\0162#.proto.SyncdMutation.Syncd"
+  "Operation\022\"\n\006record\030\002 \001(\0132\022.proto.SyncdR"
+  "ecord\"%\n\016SyncdOperation\022\007\n\003SET\020\000\022\n\n\006REMO"
+  "VE\020\001\"9\n\016SyncdMutations\022\'\n\tmutations\030\001 \003("
+  "\0132\024.proto.SyncdMutation\"\220\002\n\nSyncdPatch\022$"
+  "\n\007version\030\001 \001(\0132\023.proto.SyncdVersion\022\'\n\t"
+  "mutations\030\002 \003(\0132\024.proto.SyncdMutation\0227\n"
+  "\021externalMutations\030\003 \001(\0132\034.proto.Externa"
+  "lBlobReference\022\023\n\013snapshotMac\030\004 \001(\014\022\020\n\010p"
+  "atchMac\030\005 \001(\014\022\033\n\005keyId\030\006 \001(\0132\014.proto.Key"
+  "Id\022!\n\010exitCode\030\007 \001(\0132\017.proto.ExitCode\022\023\n"
+  "\013deviceIndex\030\010 \001(\r\"n\n\013SyncdRecord\022 \n\005ind"
+  "ex\030\001 \001(\0132\021.proto.SyncdIndex\022 \n\005value\030\002 \001"
+  "(\0132\021.proto.SyncdValue\022\033\n\005keyId\030\003 \001(\0132\014.p"
+  "roto.KeyId\"\204\001\n\rSyncdSnapshot\022$\n\007version\030"
+  "\001 \001(\0132\023.proto.SyncdVersion\022#\n\007records\030\002 "
+  "\003(\0132\022.proto.SyncdRecord\022\013\n\003mac\030\003 \001(\014\022\033\n\005"
+  "keyId\030\004 \001(\0132\014.proto.KeyId\"\032\n\nSyncdValue\022"
+  "\014\n\004blob\030\001 \001(\014\"\037\n\014SyncdVersion\022\017\n\007version"
+  "\030\001 \001(\004\"\300\004\n\016TemplateButton\022\r\n\005index\030\004 \001(\r"
+  "\022B\n\020quickReplyButton\030\001 \001(\0132&.proto.Templ"
+  "ateButton.QuickReplyButtonH\000\0224\n\turlButto"
+  "n\030\002 \001(\0132\037.proto.TemplateButton.URLButton"
+  "H\000\0226\n\ncallButton\030\003 \001(\0132 .proto.TemplateB"
+  "utton.CallButtonH\000\032\206\001\n\nCallButton\022;\n\013dis"
+  "playText\030\001 \001(\0132&.proto.Message.HighlyStr"
+  "ucturedMessage\022;\n\013phoneNumber\030\002 \001(\0132&.pr"
+  "oto.Message.HighlyStructuredMessage\032[\n\020Q"
+  "uickReplyButton\022;\n\013displayText\030\001 \001(\0132&.p"
+  "roto.Message.HighlyStructuredMessage\022\n\n\002"
+  "id\030\002 \001(\t\032}\n\tURLButton\022;\n\013displayText\030\001 \001"
+  "(\0132&.proto.Message.HighlyStructuredMessa"
+  "ge\0223\n\003url\030\002 \001(\0132&.proto.Message.HighlySt"
+  "ructuredMessageB\010\n\006button\"\236\001\n\013UserReceip"
+  "t\022\017\n\007userJid\030\001 \002(\t\022\030\n\020receiptTimestamp\030\002"
+  " \001(\003\022\025\n\rreadTimestamp\030\003 \001(\003\022\027\n\017playedTim"
+  "estamp\030\004 \001(\003\022\030\n\020pendingDeviceJid\030\005 \003(\t\022\032"
+  "\n\022deliveredDeviceJid\030\006 \003(\t\"\331\001\n\027VerifiedN"
+  "ameCertificate\022\017\n\007details\030\001 \001(\014\022\021\n\tsigna"
+  "ture\030\002 \001(\014\022\027\n\017serverSignature\030\003 \001(\014\032\200\001\n\007"
+  "Details\022\016\n\006serial\030\001 \001(\004\022\016\n\006issuer\030\002 \001(\t\022"
+  "\024\n\014verifiedName\030\004 \001(\t\022,\n\016localizedNames\030"
+  "\010 \003(\0132\024.proto.LocalizedName\022\021\n\tissueTime"
+  "\030\n \001(\004\"6\n\021WallpaperSettings\022\020\n\010filename\030"
+  "\001 \001(\t\022\017\n\007opacity\030\002 \001(\r\"\333\022\n\013WebFeatures\022."
+  "\n\rlabelsDisplay\030\001 \001(\0162\027.proto.WebFeature"
+  "s.Flag\0227\n\026voipIndividualOutgoing\030\002 \001(\0162\027"
+  ".proto.WebFeatures.Flag\022)\n\010groupsV3\030\003 \001("
+  "\0162\027.proto.WebFeatures.Flag\022/\n\016groupsV3Cr"
+  "eate\030\004 \001(\0162\027.proto.WebFeatures.Flag\022/\n\016c"
+  "hangeNumberV2\030\005 \001(\0162\027.proto.WebFeatures."
+  "Flag\0227\n\026queryStatusV3Thumbnail\030\006 \001(\0162\027.p"
+  "roto.WebFeatures.Flag\022.\n\rliveLocations\030\007"
+  " \001(\0162\027.proto.WebFeatures.Flag\022+\n\nqueryVn"
+  "ame\030\010 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026vo"
+  "ipIndividualIncoming\030\t \001(\0162\027.proto.WebFe"
+  "atures.Flag\0222\n\021quickRepliesQuery\030\n \001(\0162\027"
+  ".proto.WebFeatures.Flag\022)\n\010payments\030\013 \001("
+  "\0162\027.proto.WebFeatures.Flag\0221\n\020stickerPac"
+  "kQuery\030\014 \001(\0162\027.proto.WebFeatures.Flag\0223\n"
+  "\022liveLocationsFinal\030\r \001(\0162\027.proto.WebFea"
+  "tures.Flag\022+\n\nlabelsEdit\030\016 \001(\0162\027.proto.W"
+  "ebFeatures.Flag\022,\n\013mediaUpload\030\017 \001(\0162\027.p"
+  "roto.WebFeatures.Flag\022<\n\033mediaUploadRich"
+  "QuickReplies\030\022 \001(\0162\027.proto.WebFeatures.F"
+  "lag\022(\n\007vnameV2\030\023 \001(\0162\027.proto.WebFeatures"
+  ".Flag\0221\n\020videoPlaybackUrl\030\024 \001(\0162\027.proto."
+  "WebFeatures.Flag\022.\n\rstatusRanking\030\025 \001(\0162"
+  "\027.proto.WebFeatures.Flag\0224\n\023voipIndividu"
+  "alVideo\030\026 \001(\0162\027.proto.WebFeatures.Flag\0223"
+  "\n\022thirdPartyStickers\030\027 \001(\0162\027.proto.WebFe"
+  "atures.Flag\022;\n\032frequentlyForwardedSettin"
+  "g\030\030 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026grou"
+  "psV4JoinPermission\030\031 \001(\0162\027.proto.WebFeat"
+  "ures.Flag\022/\n\016recentStickers\030\032 \001(\0162\027.prot"
+  "o.WebFeatures.Flag\022(\n\007catalog\030\033 \001(\0162\027.pr"
+  "oto.WebFeatures.Flag\0220\n\017starredStickers\030"
+  "\034 \001(\0162\027.proto.WebFeatures.Flag\022.\n\rvoipGr"
+  "oupCall\030\035 \001(\0162\027.proto.WebFeatures.Flag\0220"
+  "\n\017templateMessage\030\036 \001(\0162\027.proto.WebFeatu"
+  "res.Flag\022=\n\034templateMessageInteractivity"
+  "\030\037 \001(\0162\027.proto.WebFeatures.Flag\0222\n\021ephem"
+  "eralMessages\030  \001(\0162\027.proto.WebFeatures.F"
+  "lag\0224\n\023e2ENotificationSync\030! \001(\0162\027.proto"
+  ".WebFeatures.Flag\0221\n\020recentStickersV2\030\" "
+  "\001(\0162\027.proto.WebFeatures.Flag\0221\n\020recentSt"
+  "ickersV3\030$ \001(\0162\027.proto.WebFeatures.Flag\022"
+  "+\n\nuserNotice\030% \001(\0162\027.proto.WebFeatures."
+  "Flag\022(\n\007support\030\' \001(\0162\027.proto.WebFeature"
+  "s.Flag\0220\n\017groupUiiCleanup\030( \001(\0162\027.proto."
+  "WebFeatures.Flag\022<\n\033groupDogfoodingInter"
+  "nalOnly\030) \001(\0162\027.proto.WebFeatures.Flag\022-"
+  "\n\014settingsSync\030* \001(\0162\027.proto.WebFeatures"
+  ".Flag\022*\n\tarchiveV2\030+ \001(\0162\027.proto.WebFeat"
+  "ures.Flag\022;\n\032ephemeralAllowGroupMembers\030"
+  ", \001(\0162\027.proto.WebFeatures.Flag\0225\n\024epheme"
+  "ral24HDuration\030- \001(\0162\027.proto.WebFeatures"
+  ".Flag\022/\n\016mdForceUpgrade\030. \001(\0162\027.proto.We"
+  "bFeatures.Flag\0221\n\020disappearingMode\030/ \001(\016"
+  "2\027.proto.WebFeatures.Flag\0229\n\030externalMdO"
+  "ptInAvailable\0300 \001(\0162\027.proto.WebFeatures."
+  "Flag\0229\n\030noDeleteMessageTimeLimit\0301 \001(\0162\027"
+  ".proto.WebFeatures.Flag\"K\n\004Flag\022\017\n\013NOT_S"
+  "TARTED\020\000\022\021\n\rFORCE_UPGRADE\020\001\022\017\n\013DEVELOPME"
+  "NT\020\002\022\016\n\nPRODUCTION\020\003\"\2424\n\016WebMessageInfo\022"
+  "\036\n\003key\030\001 \002(\0132\021.proto.MessageKey\022\037\n\007messa"
+  "ge\030\002 \001(\0132\016.proto.Message\022\030\n\020messageTimes"
+  "tamp\030\003 \001(\004\022,\n\006status\030\004 \001(\0162\034.proto.WebMe"
+  "ssageInfo.Status\022\023\n\013participant\030\005 \001(\t\022\033\n"
+  "\023messageC2STimestamp\030\006 \001(\004\022\016\n\006ignore\030\020 \001"
+  "(\010\022\017\n\007starred\030\021 \001(\010\022\021\n\tbroadcast\030\022 \001(\010\022\020"
+  "\n\010pushName\030\023 \001(\t\022\035\n\025mediaCiphertextSha25"
+  "6\030\024 \001(\014\022\021\n\tmulticast\030\025 \001(\010\022\017\n\007urlText\030\026 "
+  "\001(\010\022\021\n\turlNumber\030\027 \001(\010\0227\n\017messageStubTyp"
+  "e\030\030 \001(\0162\036.proto.WebMessageInfo.StubType\022"
+  "\022\n\nclearMedia\030\031 \001(\010\022\035\n\025messageStubParame"
+  "ters\030\032 \003(\t\022\020\n\010duration\030\033 \001(\r\022\016\n\006labels\030\034"
+  " \003(\t\022\'\n\013paymentInfo\030\035 \001(\0132\022.proto.Paymen"
+  "tInfo\022=\n\021finalLiveLocation\030\036 \001(\0132\".proto"
+  ".Message.LiveLocationMessage\022-\n\021quotedPa"
+  "ymentInfo\030\037 \001(\0132\022.proto.PaymentInfo\022\037\n\027e"
+  "phemeralStartTimestamp\030  \001(\004\022\031\n\021ephemera"
+  "lDuration\030! \001(\r\022\030\n\020ephemeralOffToOn\030\" \001("
+  "\010\022\032\n\022ephemeralOutOfSync\030# \001(\010\022@\n\020bizPriv"
+  "acyStatus\030$ \001(\0162&.proto.WebMessageInfo.B"
+  "izPrivacyStatus\022\027\n\017verifiedBizName\030% \001(\t"
+  "\022#\n\tmediaData\030& \001(\0132\020.proto.MediaData\022\'\n"
+  "\013photoChange\030\' \001(\0132\022.proto.PhotoChange\022\'"
+  "\n\013userReceipt\030( \003(\0132\022.proto.UserReceipt\022"
+  "\"\n\treactions\030) \003(\0132\017.proto.Reaction\022+\n\021q"
+  "uotedStickerData\030* \001(\0132\020.proto.MediaData"
+  "\022\027\n\017futureproofData\030+ \001(\014\022#\n\tstatusPsa\030,"
+  " \001(\0132\020.proto.StatusPSA\022&\n\013pollUpdates\030- "
+  "\003(\0132\021.proto.PollUpdate\022=\n\026pollAdditional"
+  "Metadata\030. \001(\0132\035.proto.PollAdditionalMet"
+  "adata\022\017\n\007agentId\030/ \001(\t\022\033\n\023statusAlreadyV"
+  "iewed\0300 \001(\010\022\025\n\rmessageSecret\0301 \001(\014\022%\n\nke"
+  "epInChat\0302 \001(\0132\021.proto.KeepInChat\022\'\n\037ori"
+  "ginalSelfAuthorUserJidString\0303 \001(\t\022\036\n\026re"
+  "vokeMessageTimestamp\0304 \001(\004\"=\n\020BizPrivacy"
+  "Status\022\010\n\004E2EE\020\000\022\006\n\002FB\020\002\022\007\n\003BSP\020\001\022\016\n\nBSP"
+  "_AND_FB\020\003\"X\n\006Status\022\t\n\005ERROR\020\000\022\013\n\007PENDIN"
+  "G\020\001\022\016\n\nSERVER_ACK\020\002\022\020\n\014DELIVERY_ACK\020\003\022\010\n"
+  "\004READ\020\004\022\n\n\006PLAYED\020\005\"\213(\n\010StubType\022\013\n\007UNKN"
+  "OWN\020\000\022\n\n\006REVOKE\020\001\022\016\n\nCIPHERTEXT\020\002\022\017\n\013FUT"
+  "UREPROOF\020\003\022\033\n\027NON_VERIFIED_TRANSITION\020\004\022"
+  "\031\n\025UNVERIFIED_TRANSITION\020\005\022\027\n\023VERIFIED_T"
+  "RANSITION\020\006\022\030\n\024VERIFIED_LOW_UNKNOWN\020\007\022\021\n"
+  "\rVERIFIED_HIGH\020\010\022\034\n\030VERIFIED_INITIAL_UNK"
+  "NOWN\020\t\022\030\n\024VERIFIED_INITIAL_LOW\020\n\022\031\n\025VERI"
+  "FIED_INITIAL_HIGH\020\013\022#\n\037VERIFIED_TRANSITI"
+  "ON_ANY_TO_NONE\020\014\022#\n\037VERIFIED_TRANSITION_"
+  "ANY_TO_HIGH\020\r\022#\n\037VERIFIED_TRANSITION_HIG"
+  "H_TO_LOW\020\016\022\'\n#VERIFIED_TRANSITION_HIGH_T"
+  "O_UNKNOWN\020\017\022&\n\"VERIFIED_TRANSITION_UNKNO"
+  "WN_TO_LOW\020\020\022&\n\"VERIFIED_TRANSITION_LOW_T"
+  "O_UNKNOWN\020\021\022#\n\037VERIFIED_TRANSITION_NONE_"
+  "TO_LOW\020\022\022\'\n#VERIFIED_TRANSITION_NONE_TO_"
+  "UNKNOWN\020\023\022\020\n\014GROUP_CREATE\020\024\022\030\n\024GROUP_CHA"
+  "NGE_SUBJECT\020\025\022\025\n\021GROUP_CHANGE_ICON\020\026\022\034\n\030"
+  "GROUP_CHANGE_INVITE_LINK\020\027\022\034\n\030GROUP_CHAN"
+  "GE_DESCRIPTION\020\030\022\031\n\025GROUP_CHANGE_RESTRIC"
+  "T\020\031\022\031\n\025GROUP_CHANGE_ANNOUNCE\020\032\022\031\n\025GROUP_"
+  "PARTICIPANT_ADD\020\033\022\034\n\030GROUP_PARTICIPANT_R"
+  "EMOVE\020\034\022\035\n\031GROUP_PARTICIPANT_PROMOTE\020\035\022\034"
+  "\n\030GROUP_PARTICIPANT_DEMOTE\020\036\022\034\n\030GROUP_PA"
+  "RTICIPANT_INVITE\020\037\022\033\n\027GROUP_PARTICIPANT_"
+  "LEAVE\020 \022#\n\037GROUP_PARTICIPANT_CHANGE_NUMB"
+  "ER\020!\022\024\n\020BROADCAST_CREATE\020\"\022\021\n\rBROADCAST_"
+  "ADD\020#\022\024\n\020BROADCAST_REMOVE\020$\022\030\n\024GENERIC_N"
+  "OTIFICATION\020%\022\030\n\024E2E_IDENTITY_CHANGED\020&\022"
+  "\021\n\rE2E_ENCRYPTED\020\'\022\025\n\021CALL_MISSED_VOICE\020"
+  "(\022\025\n\021CALL_MISSED_VIDEO\020)\022\034\n\030INDIVIDUAL_C"
+  "HANGE_NUMBER\020*\022\020\n\014GROUP_DELETE\020+\022&\n\"GROU"
+  "P_ANNOUNCE_MODE_MESSAGE_BOUNCE\020,\022\033\n\027CALL"
+  "_MISSED_GROUP_VOICE\020-\022\033\n\027CALL_MISSED_GRO"
+  "UP_VIDEO\020.\022\026\n\022PAYMENT_CIPHERTEXT\020/\022\027\n\023PA"
+  "YMENT_FUTUREPROOF\0200\022,\n(PAYMENT_TRANSACTI"
+  "ON_STATUS_UPDATE_FAILED\0201\022.\n*PAYMENT_TRA"
+  "NSACTION_STATUS_UPDATE_REFUNDED\0202\0223\n/PAY"
+  "MENT_TRANSACTION_STATUS_UPDATE_REFUND_FA"
+  "ILED\0203\0225\n1PAYMENT_TRANSACTION_STATUS_REC"
+  "EIVER_PENDING_SETUP\0204\022<\n8PAYMENT_TRANSAC"
+  "TION_STATUS_RECEIVER_SUCCESS_AFTER_HICCU"
+  "P\0205\022)\n%PAYMENT_ACTION_ACCOUNT_SETUP_REMI"
+  "NDER\0206\022(\n$PAYMENT_ACTION_SEND_PAYMENT_RE"
+  "MINDER\0207\022*\n&PAYMENT_ACTION_SEND_PAYMENT_"
+  "INVITATION\0208\022#\n\037PAYMENT_ACTION_REQUEST_D"
+  "ECLINED\0209\022\"\n\036PAYMENT_ACTION_REQUEST_EXPI"
+  "RED\020:\022$\n PAYMENT_ACTION_REQUEST_CANCELLE"
+  "D\020;\022)\n%BIZ_VERIFIED_TRANSITION_TOP_TO_BO"
+  "TTOM\020<\022)\n%BIZ_VERIFIED_TRANSITION_BOTTOM"
+  "_TO_TOP\020=\022\021\n\rBIZ_INTRO_TOP\020>\022\024\n\020BIZ_INTR"
+  "O_BOTTOM\020\?\022\023\n\017BIZ_NAME_CHANGE\020@\022\034\n\030BIZ_M"
+  "OVE_TO_CONSUMER_APP\020A\022\036\n\032BIZ_TWO_TIER_MI"
+  "GRATION_TOP\020B\022!\n\035BIZ_TWO_TIER_MIGRATION_"
+  "BOTTOM\020C\022\r\n\tOVERSIZED\020D\022(\n$GROUP_CHANGE_"
+  "NO_FREQUENTLY_FORWARDED\020E\022\034\n\030GROUP_V4_AD"
+  "D_INVITE_SENT\020F\022&\n\"GROUP_PARTICIPANT_ADD"
+  "_REQUEST_JOIN\020G\022\034\n\030CHANGE_EPHEMERAL_SETT"
+  "ING\020H\022\026\n\022E2E_DEVICE_CHANGED\020I\022\017\n\013VIEWED_"
+  "ONCE\020J\022\025\n\021E2E_ENCRYPTED_NOW\020K\022\"\n\036BLUE_MS"
+  "G_BSP_FB_TO_BSP_PREMISE\020L\022\036\n\032BLUE_MSG_BS"
+  "P_FB_TO_SELF_FB\020M\022#\n\037BLUE_MSG_BSP_FB_TO_"
+  "SELF_PREMISE\020N\022\036\n\032BLUE_MSG_BSP_FB_UNVERI"
+  "FIED\020O\0227\n3BLUE_MSG_BSP_FB_UNVERIFIED_TO_"
+  "SELF_PREMISE_VERIFIED\020P\022\034\n\030BLUE_MSG_BSP_"
+  "FB_VERIFIED\020Q\0227\n3BLUE_MSG_BSP_FB_VERIFIE"
+  "D_TO_SELF_PREMISE_UNVERIFIED\020R\022(\n$BLUE_M"
+  "SG_BSP_PREMISE_TO_SELF_PREMISE\020S\022#\n\037BLUE"
+  "_MSG_BSP_PREMISE_UNVERIFIED\020T\022<\n8BLUE_MS"
+  "G_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE"
+  "_VERIFIED\020U\022!\n\035BLUE_MSG_BSP_PREMISE_VERI"
+  "FIED\020V\022<\n8BLUE_MSG_BSP_PREMISE_VERIFIED_"
+  "TO_SELF_PREMISE_UNVERIFIED\020W\022*\n&BLUE_MSG"
+  "_CONSUMER_TO_BSP_FB_UNVERIFIED\020X\022/\n+BLUE"
+  "_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED\020"
+  "Y\022+\n\'BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERI"
+  "FIED\020Z\0220\n,BLUE_MSG_CONSUMER_TO_SELF_PREM"
+  "ISE_UNVERIFIED\020[\022#\n\037BLUE_MSG_SELF_FB_TO_"
+  "BSP_PREMISE\020\\\022$\n BLUE_MSG_SELF_FB_TO_SEL"
+  "F_PREMISE\020]\022\037\n\033BLUE_MSG_SELF_FB_UNVERIFI"
+  "ED\020^\0228\n4BLUE_MSG_SELF_FB_UNVERIFIED_TO_S"
+  "ELF_PREMISE_VERIFIED\020_\022\035\n\031BLUE_MSG_SELF_"
+  "FB_VERIFIED\020`\0228\n4BLUE_MSG_SELF_FB_VERIFI"
+  "ED_TO_SELF_PREMISE_UNVERIFIED\020a\022(\n$BLUE_"
+  "MSG_SELF_PREMISE_TO_BSP_PREMISE\020b\022$\n BLU"
+  "E_MSG_SELF_PREMISE_UNVERIFIED\020c\022\"\n\036BLUE_"
+  "MSG_SELF_PREMISE_VERIFIED\020d\022\026\n\022BLUE_MSG_"
+  "TO_BSP_FB\020e\022\030\n\024BLUE_MSG_TO_CONSUMER\020f\022\027\n"
+  "\023BLUE_MSG_TO_SELF_FB\020g\022*\n&BLUE_MSG_UNVER"
+  "IFIED_TO_BSP_FB_VERIFIED\020h\022/\n+BLUE_MSG_U"
+  "NVERIFIED_TO_BSP_PREMISE_VERIFIED\020i\022+\n\'B"
+  "LUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED\020j"
+  "\022#\n\037BLUE_MSG_UNVERIFIED_TO_VERIFIED\020k\022*\n"
+  "&BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED\020"
+  "l\022/\n+BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UN"
+  "VERIFIED\020m\022+\n\'BLUE_MSG_VERIFIED_TO_SELF_"
+  "FB_UNVERIFIED\020n\022#\n\037BLUE_MSG_VERIFIED_TO_"
+  "UNVERIFIED\020o\0226\n2BLUE_MSG_BSP_FB_UNVERIFI"
+  "ED_TO_BSP_PREMISE_VERIFIED\020p\0222\n.BLUE_MSG"
+  "_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED\020q"
+  "\0226\n2BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREM"
+  "ISE_UNVERIFIED\020r\0222\n.BLUE_MSG_BSP_FB_VERI"
+  "FIED_TO_SELF_FB_UNVERIFIED\020s\0227\n3BLUE_MSG"
+  "_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIF"
+  "IED\020t\0227\n3BLUE_MSG_SELF_FB_VERIFIED_TO_BS"
+  "P_PREMISE_UNVERIFIED\020u\022\034\n\030E2E_IDENTITY_U"
+  "NAVAILABLE\020v\022\022\n\016GROUP_CREATING\020w\022\027\n\023GROU"
+  "P_CREATE_FAILED\020x\022\021\n\rGROUP_BOUNCED\020y\022\021\n\r"
+  "BLOCK_CONTACT\020z\022!\n\035EPHEMERAL_SETTING_NOT"
+  "_APPLIED\020{\022\017\n\013SYNC_FAILED\020|\022\013\n\007SYNCING\020}"
+  "\022\034\n\030BIZ_PRIVACY_MODE_INIT_FB\020~\022\035\n\031BIZ_PR"
+  "IVACY_MODE_INIT_BSP\020\177\022\033\n\026BIZ_PRIVACY_MOD"
+  "E_TO_FB\020\200\001\022\034\n\027BIZ_PRIVACY_MODE_TO_BSP\020\201\001"
+  "\022\026\n\021DISAPPEARING_MODE\020\202\001\022\034\n\027E2E_DEVICE_F"
+  "ETCH_FAILED\020\203\001\022\021\n\014ADMIN_REVOKE\020\204\001\022$\n\037GRO"
+  "UP_INVITE_LINK_GROWTH_LOCKED\020\205\001\022 \n\033COMMU"
+  "NITY_LINK_PARENT_GROUP\020\206\001\022!\n\034COMMUNITY_L"
+  "INK_SIBLING_GROUP\020\207\001\022\035\n\030COMMUNITY_LINK_S"
+  "UB_GROUP\020\210\001\022\"\n\035COMMUNITY_UNLINK_PARENT_G"
+  "ROUP\020\211\001\022#\n\036COMMUNITY_UNLINK_SIBLING_GROU"
+  "P\020\212\001\022\037\n\032COMMUNITY_UNLINK_SUB_GROUP\020\213\001\022\035\n"
+  "\030GROUP_PARTICIPANT_ACCEPT\020\214\001\022(\n#GROUP_PA"
+  "RTICIPANT_LINKED_GROUP_JOIN\020\215\001\022\025\n\020COMMUN"
+  "ITY_CREATE\020\216\001\022\033\n\026EPHEMERAL_KEEP_IN_CHAT\020"
+  "\217\001\022+\n&GROUP_MEMBERSHIP_JOIN_APPROVAL_REQ"
+  "UEST\020\220\001\022(\n#GROUP_MEMBERSHIP_JOIN_APPROVA"
+  "L_MODE\020\221\001\022\"\n\035INTEGRITY_UNLINK_PARENT_GRO"
+  "UP\020\222\001\022\"\n\035COMMUNITY_PARTICIPANT_PROMOTE\020\223"
+  "\001\022!\n\034COMMUNITY_PARTICIPANT_DEMOTE\020\224\001\022#\n\036"
+  "COMMUNITY_PARENT_GROUP_DELETED\020\225\001\"\211\001\n\024We"
+  "bNotificationsInfo\022\021\n\ttimestamp\030\002 \001(\004\022\023\n"
+  "\013unreadChats\030\003 \001(\r\022\032\n\022notifyMessageCount"
+  "\030\004 \001(\r\022-\n\016notifyMessages\030\005 \003(\0132\025.proto.W"
+  "ebMessageInfo*@\n\010KeepType\022\013\n\007UNKNOWN\020\000\022\020"
+  "\n\014KEEP_FOR_ALL\020\001\022\025\n\021UNDO_KEEP_FOR_ALL\020\002*"
+  "/\n\017MediaVisibility\022\013\n\007DEFAULT\020\000\022\007\n\003OFF\020\001"
+  "\022\006\n\002ON\020\002"
+  ;
+static ::_pbi::once_flag descriptor_table_pmsg_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_pmsg_2eproto = {
+    false, false, 52848, descriptor_table_protodef_pmsg_2eproto,
+    "pmsg.proto",
+    &descriptor_table_pmsg_2eproto_once, nullptr, 0, 224,
+    schemas, file_default_instances, TableStruct_pmsg_2eproto::offsets,
+    file_level_metadata_pmsg_2eproto, file_level_enum_descriptors_pmsg_2eproto,
+    file_level_service_descriptors_pmsg_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_pmsg_2eproto_getter() {
+  return &descriptor_table_pmsg_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_pmsg_2eproto(&descriptor_table_pmsg_2eproto);
+namespace proto {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[0];
+}
+bool BizAccountLinkInfo_AccountType_IsValid(int value) {
+  switch (value) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::ENTERPRISE;
+constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MIN;
+constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MAX;
+constexpr int BizAccountLinkInfo::AccountType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[1];
+}
+bool BizAccountLinkInfo_HostStorageType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::ON_PREMISE;
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::FACEBOOK;
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MIN;
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MAX;
+constexpr int BizAccountLinkInfo::HostStorageType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[2];
+}
+bool BizIdentityInfo_ActualActorsType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::SELF;
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::BSP;
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MIN;
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MAX;
+constexpr int BizIdentityInfo::ActualActorsType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[3];
+}
+bool BizIdentityInfo_HostStorageType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::ON_PREMISE;
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::FACEBOOK;
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MIN;
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MAX;
+constexpr int BizIdentityInfo::HostStorageType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[4];
+}
+bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::UNKNOWN;
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::LOW;
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::HIGH;
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MIN;
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MAX;
+constexpr int BizIdentityInfo::VerifiedLevelValue_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[5];
+}
+bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::SYSTEM;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::GOOGLE;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::HARDCODED;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::OVERRIDE;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::FALLBACK;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MIN;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MAX;
+constexpr int ClientPayload_DNSSource::DNSResolutionMethod_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[6];
+}
+bool ClientPayload_UserAgent_Platform_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+    case 28:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IOS;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS_PHONE;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRY;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRYX;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S40;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S60;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PYTHON_CLIENT;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::TIZEN;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ENTERPRISE;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::KAIOS;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_IOS;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WEB;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PORTAL;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_IPHONE;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_IPHONE;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::FBLITE_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MLITE_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IGLITE_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PAGE;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MACOS;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_MSG;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_CALL;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MILAN;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::CAPI;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MIN;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MAX;
+constexpr int ClientPayload_UserAgent::Platform_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[7];
+}
+bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::RELEASE;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::BETA;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ALPHA;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::DEBUG;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MIN;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MAX;
+constexpr int ClientPayload_UserAgent::ReleaseChannel_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[8];
+}
+bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WEB_BROWSER;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::APP_STORE;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WIN_STORE;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::DARWIN;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WINDA;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MIN;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MAX;
+constexpr int ClientPayload_WebInfo::WebSubPlatform_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[9];
+}
+bool ClientPayload_ConnectReason_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_ConnectReason ClientPayload::PUSH;
+constexpr ClientPayload_ConnectReason ClientPayload::USER_ACTIVATED;
+constexpr ClientPayload_ConnectReason ClientPayload::SCHEDULED;
+constexpr ClientPayload_ConnectReason ClientPayload::ERROR_RECONNECT;
+constexpr ClientPayload_ConnectReason ClientPayload::NETWORK_SWITCH;
+constexpr ClientPayload_ConnectReason ClientPayload::PING_RECONNECT;
+constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MIN;
+constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MAX;
+constexpr int ClientPayload::ConnectReason_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[10];
+}
+bool ClientPayload_ConnectType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 100:
+    case 101:
+    case 102:
+    case 103:
+    case 104:
+    case 105:
+    case 106:
+    case 107:
+    case 108:
+    case 109:
+    case 110:
+    case 111:
+    case 112:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UNKNOWN;
+constexpr ClientPayload_ConnectType ClientPayload::WIFI_UNKNOWN;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EDGE;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_IDEN;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UMTS;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EVDO;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_GPRS;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSDPA;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSUPA;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPA;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_CDMA;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_1XRTT;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EHRPD;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_LTE;
+constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPAP;
+constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MIN;
+constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MAX;
+constexpr int ClientPayload::ConnectType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[11];
+}
+bool ClientPayload_IOSAppExtension_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_IOSAppExtension ClientPayload::SHARE_EXTENSION;
+constexpr ClientPayload_IOSAppExtension ClientPayload::SERVICE_EXTENSION;
+constexpr ClientPayload_IOSAppExtension ClientPayload::INTENTS_EXTENSION;
+constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MIN;
+constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MAX;
+constexpr int ClientPayload::IOSAppExtension_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[12];
+}
+bool ClientPayload_Product_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientPayload_Product ClientPayload::WHATSAPP;
+constexpr ClientPayload_Product ClientPayload::MESSENGER;
+constexpr ClientPayload_Product ClientPayload::Product_MIN;
+constexpr ClientPayload_Product ClientPayload::Product_MAX;
+constexpr int ClientPayload::Product_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[13];
+}
+bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::NONE;
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::IMAGE;
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::VIDEO;
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MIN;
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MAX;
+constexpr int ContextInfo_AdReplyInfo::MediaType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[14];
+}
+bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::NONE;
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::IMAGE;
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::VIDEO;
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MIN;
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MAX;
+constexpr int ContextInfo_ExternalAdReplyInfo::MediaType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[15];
+}
+bool Conversation_EndOfHistoryTransferType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY;
+constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY;
+constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MIN;
+constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MAX;
+constexpr int Conversation::EndOfHistoryTransferType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[16];
+}
+bool DeviceProps_PlatformType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr DeviceProps_PlatformType DeviceProps::UNKNOWN;
+constexpr DeviceProps_PlatformType DeviceProps::CHROME;
+constexpr DeviceProps_PlatformType DeviceProps::FIREFOX;
+constexpr DeviceProps_PlatformType DeviceProps::IE;
+constexpr DeviceProps_PlatformType DeviceProps::OPERA;
+constexpr DeviceProps_PlatformType DeviceProps::SAFARI;
+constexpr DeviceProps_PlatformType DeviceProps::EDGE;
+constexpr DeviceProps_PlatformType DeviceProps::DESKTOP;
+constexpr DeviceProps_PlatformType DeviceProps::IPAD;
+constexpr DeviceProps_PlatformType DeviceProps::ANDROID_TABLET;
+constexpr DeviceProps_PlatformType DeviceProps::OHANA;
+constexpr DeviceProps_PlatformType DeviceProps::ALOHA;
+constexpr DeviceProps_PlatformType DeviceProps::CATALINA;
+constexpr DeviceProps_PlatformType DeviceProps::TCL_TV;
+constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MIN;
+constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MAX;
+constexpr int DeviceProps::PlatformType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[17];
+}
+bool DisappearingMode_Initiator_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr DisappearingMode_Initiator DisappearingMode::CHANGED_IN_CHAT;
+constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_ME;
+constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_OTHER;
+constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MIN;
+constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MAX;
+constexpr int DisappearingMode::Initiator_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[18];
+}
+bool GroupParticipant_Rank_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr GroupParticipant_Rank GroupParticipant::REGULAR;
+constexpr GroupParticipant_Rank GroupParticipant::ADMIN;
+constexpr GroupParticipant_Rank GroupParticipant::SUPERADMIN;
+constexpr GroupParticipant_Rank GroupParticipant::Rank_MIN;
+constexpr GroupParticipant_Rank GroupParticipant::Rank_MAX;
+constexpr int GroupParticipant::Rank_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[19];
+}
+bool HistorySync_HistorySyncType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr HistorySync_HistorySyncType HistorySync::INITIAL_BOOTSTRAP;
+constexpr HistorySync_HistorySyncType HistorySync::INITIAL_STATUS_V3;
+constexpr HistorySync_HistorySyncType HistorySync::FULL;
+constexpr HistorySync_HistorySyncType HistorySync::RECENT;
+constexpr HistorySync_HistorySyncType HistorySync::PUSH_NAME;
+constexpr HistorySync_HistorySyncType HistorySync::UNBLOCKING_DATA;
+constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MIN;
+constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MAX;
+constexpr int HistorySync::HistorySyncType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[20];
+}
+bool MediaRetryNotification_ResultType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::GENERAL_ERROR;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::SUCCESS;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::NOT_FOUND;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::DECRYPTION_ERROR;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MIN;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MAX;
+constexpr int MediaRetryNotification::ResultType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[21];
+}
+bool Message_ButtonsMessage_Button_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::UNKNOWN;
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::RESPONSE;
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::NATIVE_FLOW;
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MIN;
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MAX;
+constexpr int Message_ButtonsMessage_Button::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[22];
+}
+bool Message_ButtonsMessage_HeaderType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::UNKNOWN;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::EMPTY;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::TEXT;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::DOCUMENT;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::IMAGE;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::VIDEO;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::LOCATION;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MIN;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MAX;
+constexpr int Message_ButtonsMessage::HeaderType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[23];
+}
+bool Message_ButtonsResponseMessage_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::UNKNOWN;
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::DISPLAY_TEXT;
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MIN;
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MAX;
+constexpr int Message_ButtonsResponseMessage::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[24];
+}
+bool Message_ExtendedTextMessage_FontType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SANS_SERIF;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SERIF;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::NORICAN_REGULAR;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BRYNDAN_WRITE;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BEBASNEUE_REGULAR;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::OSWALD_HEAVY;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MIN;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MAX;
+constexpr int Message_ExtendedTextMessage::FontType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[25];
+}
+bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::PARENT;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::SUB;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT_SUB;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MIN;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MAX;
+constexpr int Message_ExtendedTextMessage::InviteLinkGroupType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[26];
+}
+bool Message_ExtendedTextMessage_PreviewType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::NONE;
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::VIDEO;
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MIN;
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MAX;
+constexpr int Message_ExtendedTextMessage::PreviewType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[27];
+}
+bool Message_GroupInviteMessage_GroupType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::DEFAULT;
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::PARENT;
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MIN;
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MAX;
+constexpr int Message_GroupInviteMessage::GroupType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[28];
+}
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value) {
+  switch (value) {
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GREGORIAN;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SOLAR_HIJRI;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MIN;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MAX;
+constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[29];
+}
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value) {
+  switch (value) {
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MONDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::TUESDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::WEDNESDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::THURSDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::FRIDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SATURDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SUNDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MIN;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MAX;
+constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[30];
+}
+bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_BOOTSTRAP;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_STATUS_V3;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::FULL;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::RECENT;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::PUSH_NAME;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MIN;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MAX;
+constexpr int Message_HistorySyncNotification::HistorySyncType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[31];
+}
+bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::UNKNOWN_SURFACE;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::FB;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::IG;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::WA;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MIN;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MAX;
+constexpr int Message_InteractiveMessage_ShopMessage::Surface_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[32];
+}
+bool Message_InvoiceMessage_AttachmentType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::IMAGE;
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::PDF;
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MIN;
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MAX;
+constexpr int Message_InvoiceMessage::AttachmentType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[33];
+}
+bool Message_ListMessage_ListType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ListMessage_ListType Message_ListMessage::UNKNOWN;
+constexpr Message_ListMessage_ListType Message_ListMessage::SINGLE_SELECT;
+constexpr Message_ListMessage_ListType Message_ListMessage::PRODUCT_LIST;
+constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MIN;
+constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MAX;
+constexpr int Message_ListMessage::ListType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[34];
+}
+bool Message_ListResponseMessage_ListType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::UNKNOWN;
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::SINGLE_SELECT;
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MIN;
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MAX;
+constexpr int Message_ListResponseMessage::ListType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[35];
+}
+bool Message_OrderMessage_OrderStatus_IsValid(int value) {
+  switch (value) {
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::INQUIRY;
+constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MIN;
+constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MAX;
+constexpr int Message_OrderMessage::OrderStatus_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[36];
+}
+bool Message_OrderMessage_OrderSurface_IsValid(int value) {
+  switch (value) {
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::CATALOG;
+constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MIN;
+constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MAX;
+constexpr int Message_OrderMessage::OrderSurface_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[37];
+}
+bool Message_PaymentInviteMessage_ServiceType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UNKNOWN;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::FBPAY;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::NOVI;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UPI;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MIN;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MAX;
+constexpr int Message_PaymentInviteMessage::ServiceType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[38];
+}
+bool Message_ProtocolMessage_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REVOKE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SETTING;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SYNC_RESPONSE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::HISTORY_SYNC_NOTIFICATION;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_SHARE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_REQUEST;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::MSG_FANOUT_BACKFILL_REQUEST;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_FATAL_EXCEPTION_NOTIFICATION;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::SHARE_PHONE_NUMBER;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_MESSAGE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MIN;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MAX;
+constexpr int Message_ProtocolMessage::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[39];
+}
+bool Message_VideoMessage_Attribution_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_VideoMessage_Attribution Message_VideoMessage::NONE;
+constexpr Message_VideoMessage_Attribution Message_VideoMessage::GIPHY;
+constexpr Message_VideoMessage_Attribution Message_VideoMessage::TENOR;
+constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MIN;
+constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MAX;
+constexpr int Message_VideoMessage::Attribution_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[40];
+}
+bool Message_RmrSource_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Message_RmrSource Message::FAVORITE_STICKER;
+constexpr Message_RmrSource Message::RECENT_STICKER;
+constexpr Message_RmrSource Message::RmrSource_MIN;
+constexpr Message_RmrSource Message::RmrSource_MAX;
+constexpr int Message::RmrSource_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[41];
+}
+bool PastParticipant_LeaveReason_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr PastParticipant_LeaveReason PastParticipant::LEFT;
+constexpr PastParticipant_LeaveReason PastParticipant::REMOVED;
+constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MIN;
+constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MAX;
+constexpr int PastParticipant::LeaveReason_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[42];
+}
+bool PaymentBackground_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr PaymentBackground_Type PaymentBackground::UNKNOWN;
+constexpr PaymentBackground_Type PaymentBackground::DEFAULT;
+constexpr PaymentBackground_Type PaymentBackground::Type_MIN;
+constexpr PaymentBackground_Type PaymentBackground::Type_MAX;
+constexpr int PaymentBackground::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[43];
+}
+bool PaymentInfo_Currency_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr PaymentInfo_Currency PaymentInfo::UNKNOWN_CURRENCY;
+constexpr PaymentInfo_Currency PaymentInfo::INR;
+constexpr PaymentInfo_Currency PaymentInfo::Currency_MIN;
+constexpr PaymentInfo_Currency PaymentInfo::Currency_MAX;
+constexpr int PaymentInfo::Currency_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[44];
+}
+bool PaymentInfo_Status_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr PaymentInfo_Status PaymentInfo::UNKNOWN_STATUS;
+constexpr PaymentInfo_Status PaymentInfo::PROCESSING;
+constexpr PaymentInfo_Status PaymentInfo::SENT;
+constexpr PaymentInfo_Status PaymentInfo::NEED_TO_ACCEPT;
+constexpr PaymentInfo_Status PaymentInfo::COMPLETE;
+constexpr PaymentInfo_Status PaymentInfo::COULD_NOT_COMPLETE;
+constexpr PaymentInfo_Status PaymentInfo::REFUNDED;
+constexpr PaymentInfo_Status PaymentInfo::EXPIRED;
+constexpr PaymentInfo_Status PaymentInfo::REJECTED;
+constexpr PaymentInfo_Status PaymentInfo::CANCELLED;
+constexpr PaymentInfo_Status PaymentInfo::WAITING_FOR_PAYER;
+constexpr PaymentInfo_Status PaymentInfo::WAITING;
+constexpr PaymentInfo_Status PaymentInfo::Status_MIN;
+constexpr PaymentInfo_Status PaymentInfo::Status_MAX;
+constexpr int PaymentInfo::Status_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[45];
+}
+bool PaymentInfo_TxnStatus_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+    case 28:
+    case 29:
+    case 30:
+    case 31:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr PaymentInfo_TxnStatus PaymentInfo::UNKNOWN;
+constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_SETUP;
+constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_RECEIVER_SETUP;
+constexpr PaymentInfo_TxnStatus PaymentInfo::INIT;
+constexpr PaymentInfo_TxnStatus PaymentInfo::SUCCESS;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COMPLETED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RISK;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_PROCESSING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RECEIVER_PROCESSING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA;
+constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA_FINAL;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REFUNDED_TXN;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_PROCESSING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_DA;
+constexpr PaymentInfo_TxnStatus PaymentInfo::EXPIRED_TXN;
+constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCELED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED_PROCESSING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_INIT;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_SUCCESS;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED_RISK;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_REJECTED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_EXPIRED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELED;
+constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELLING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::IN_REVIEW;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_SUCCESS;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_PENDING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_PENDING;
+constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MIN;
+constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MAX;
+constexpr int PaymentInfo::TxnStatus_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[46];
+}
+bool SyncdMutation_SyncdOperation_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr SyncdMutation_SyncdOperation SyncdMutation::SET;
+constexpr SyncdMutation_SyncdOperation SyncdMutation::REMOVE;
+constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MIN;
+constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MAX;
+constexpr int SyncdMutation::SyncdOperation_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[47];
+}
+bool WebFeatures_Flag_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr WebFeatures_Flag WebFeatures::NOT_STARTED;
+constexpr WebFeatures_Flag WebFeatures::FORCE_UPGRADE;
+constexpr WebFeatures_Flag WebFeatures::DEVELOPMENT;
+constexpr WebFeatures_Flag WebFeatures::PRODUCTION;
+constexpr WebFeatures_Flag WebFeatures::Flag_MIN;
+constexpr WebFeatures_Flag WebFeatures::Flag_MAX;
+constexpr int WebFeatures::Flag_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[48];
+}
+bool WebMessageInfo_BizPrivacyStatus_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::E2EE;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::FB;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP_AND_FB;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MIN;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MAX;
+constexpr int WebMessageInfo::BizPrivacyStatus_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[49];
+}
+bool WebMessageInfo_Status_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr WebMessageInfo_Status WebMessageInfo::ERROR;
+constexpr WebMessageInfo_Status WebMessageInfo::PENDING;
+constexpr WebMessageInfo_Status WebMessageInfo::SERVER_ACK;
+constexpr WebMessageInfo_Status WebMessageInfo::DELIVERY_ACK;
+constexpr WebMessageInfo_Status WebMessageInfo::READ;
+constexpr WebMessageInfo_Status WebMessageInfo::PLAYED;
+constexpr WebMessageInfo_Status WebMessageInfo::Status_MIN;
+constexpr WebMessageInfo_Status WebMessageInfo::Status_MAX;
+constexpr int WebMessageInfo::Status_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[50];
+}
+bool WebMessageInfo_StubType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+    case 28:
+    case 29:
+    case 30:
+    case 31:
+    case 32:
+    case 33:
+    case 34:
+    case 35:
+    case 36:
+    case 37:
+    case 38:
+    case 39:
+    case 40:
+    case 41:
+    case 42:
+    case 43:
+    case 44:
+    case 45:
+    case 46:
+    case 47:
+    case 48:
+    case 49:
+    case 50:
+    case 51:
+    case 52:
+    case 53:
+    case 54:
+    case 55:
+    case 56:
+    case 57:
+    case 58:
+    case 59:
+    case 60:
+    case 61:
+    case 62:
+    case 63:
+    case 64:
+    case 65:
+    case 66:
+    case 67:
+    case 68:
+    case 69:
+    case 70:
+    case 71:
+    case 72:
+    case 73:
+    case 74:
+    case 75:
+    case 76:
+    case 77:
+    case 78:
+    case 79:
+    case 80:
+    case 81:
+    case 82:
+    case 83:
+    case 84:
+    case 85:
+    case 86:
+    case 87:
+    case 88:
+    case 89:
+    case 90:
+    case 91:
+    case 92:
+    case 93:
+    case 94:
+    case 95:
+    case 96:
+    case 97:
+    case 98:
+    case 99:
+    case 100:
+    case 101:
+    case 102:
+    case 103:
+    case 104:
+    case 105:
+    case 106:
+    case 107:
+    case 108:
+    case 109:
+    case 110:
+    case 111:
+    case 112:
+    case 113:
+    case 114:
+    case 115:
+    case 116:
+    case 117:
+    case 118:
+    case 119:
+    case 120:
+    case 121:
+    case 122:
+    case 123:
+    case 124:
+    case 125:
+    case 126:
+    case 127:
+    case 128:
+    case 129:
+    case 130:
+    case 131:
+    case 132:
+    case 133:
+    case 134:
+    case 135:
+    case 136:
+    case 137:
+    case 138:
+    case 139:
+    case 140:
+    case 141:
+    case 142:
+    case 143:
+    case 144:
+    case 145:
+    case 146:
+    case 147:
+    case 148:
+    case 149:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr WebMessageInfo_StubType WebMessageInfo::UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::REVOKE;
+constexpr WebMessageInfo_StubType WebMessageInfo::CIPHERTEXT;
+constexpr WebMessageInfo_StubType WebMessageInfo::FUTUREPROOF;
+constexpr WebMessageInfo_StubType WebMessageInfo::NON_VERIFIED_TRANSITION;
+constexpr WebMessageInfo_StubType WebMessageInfo::UNVERIFIED_TRANSITION;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_LOW_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_HIGH;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_LOW;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_HIGH;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_NONE;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_HIGH;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_LOW;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_UNKNOWN_TO_LOW;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_LOW_TO_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_LOW;
+constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_SUBJECT;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ICON;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_INVITE_LINK;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_DESCRIPTION;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_RESTRICT;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ANNOUNCE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_REMOVE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_PROMOTE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_DEMOTE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_INVITE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LEAVE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_CHANGE_NUMBER;
+constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_CREATE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_ADD;
+constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_REMOVE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GENERIC_NOTIFICATION;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_CHANGED;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED;
+constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VOICE;
+constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VIDEO;
+constexpr WebMessageInfo_StubType WebMessageInfo::INDIVIDUAL_CHANGE_NUMBER;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_DELETE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE;
+constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VOICE;
+constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VIDEO;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_CIPHERTEXT;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_FUTUREPROOF;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_REMINDER;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_INVITATION;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_DECLINED;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_EXPIRED;
+constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_CANCELLED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_TOP;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_BOTTOM;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_NAME_CHANGE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_MOVE_TO_CONSUMER_APP;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_TOP;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_BOTTOM;
+constexpr WebMessageInfo_StubType WebMessageInfo::OVERSIZED;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_NO_FREQUENTLY_FORWARDED;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_V4_ADD_INVITE_SENT;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN;
+constexpr WebMessageInfo_StubType WebMessageInfo::CHANGE_EPHEMERAL_SETTING;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_CHANGED;
+constexpr WebMessageInfo_StubType WebMessageInfo::VIEWED_ONCE;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED_NOW;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_BSP_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_FB;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_BSP_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_SELF_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_BSP_FB;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_CONSUMER;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_SELF_FB;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_UNAVAILABLE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATING;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE_FAILED;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_BOUNCED;
+constexpr WebMessageInfo_StubType WebMessageInfo::BLOCK_CONTACT;
+constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_SETTING_NOT_APPLIED;
+constexpr WebMessageInfo_StubType WebMessageInfo::SYNC_FAILED;
+constexpr WebMessageInfo_StubType WebMessageInfo::SYNCING;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_FB;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_BSP;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_FB;
+constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_BSP;
+constexpr WebMessageInfo_StubType WebMessageInfo::DISAPPEARING_MODE;
+constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_FETCH_FAILED;
+constexpr WebMessageInfo_StubType WebMessageInfo::ADMIN_REVOKE;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_INVITE_LINK_GROWTH_LOCKED;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_PARENT_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SIBLING_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SUB_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_PARENT_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SIBLING_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SUB_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ACCEPT;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LINKED_GROUP_JOIN;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_CREATE;
+constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_KEEP_IN_CHAT;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST;
+constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE;
+constexpr WebMessageInfo_StubType WebMessageInfo::INTEGRITY_UNLINK_PARENT_GROUP;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_PROMOTE;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_DEMOTE;
+constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARENT_GROUP_DELETED;
+constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MIN;
+constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MAX;
+constexpr int WebMessageInfo::StubType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[51];
+}
+bool KeepType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto);
+  return file_level_enum_descriptors_pmsg_2eproto[52];
+}
+bool MediaVisibility_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+class ADVDeviceIdentity::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ADVDeviceIdentity>()._impl_._has_bits_);
+  static void set_has_rawid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_keyindex(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ADVDeviceIdentity::ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ADVDeviceIdentity)
+}
+ADVDeviceIdentity::ADVDeviceIdentity(const ADVDeviceIdentity& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ADVDeviceIdentity* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){}
+    , decltype(_impl_.rawid_){}
+    , decltype(_impl_.keyindex_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.keyindex_) -
+    reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_));
+  // @@protoc_insertion_point(copy_constructor:proto.ADVDeviceIdentity)
+}
+
+inline void ADVDeviceIdentity::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){uint64_t{0u}}
+    , decltype(_impl_.rawid_){0u}
+    , decltype(_impl_.keyindex_){0u}
+  };
+}
+
+ADVDeviceIdentity::~ADVDeviceIdentity() {
+  // @@protoc_insertion_point(destructor:proto.ADVDeviceIdentity)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ADVDeviceIdentity::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ADVDeviceIdentity::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ADVDeviceIdentity::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ADVDeviceIdentity)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.keyindex_) -
+        reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ADVDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 rawId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_rawid(&has_bits);
+          _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 keyIndex = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_keyindex(&has_bits);
+          _impl_.keyindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ADVDeviceIdentity::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ADVDeviceIdentity)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 rawId = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target);
+  }
+
+  // optional uint64 timestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  // optional uint32 keyIndex = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_keyindex(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ADVDeviceIdentity)
+  return target;
+}
+
+size_t ADVDeviceIdentity::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ADVDeviceIdentity)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional uint64 timestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp());
+    }
+
+    // optional uint32 rawId = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid());
+    }
+
+    // optional uint32 keyIndex = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_keyindex());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVDeviceIdentity::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ADVDeviceIdentity::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVDeviceIdentity::GetClassData() const { return &_class_data_; }
+
+
+void ADVDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ADVDeviceIdentity*>(&to_msg);
+  auto& from = static_cast<const ADVDeviceIdentity&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVDeviceIdentity)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.rawid_ = from._impl_.rawid_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.keyindex_ = from._impl_.keyindex_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ADVDeviceIdentity::CopyFrom(const ADVDeviceIdentity& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVDeviceIdentity)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ADVDeviceIdentity::IsInitialized() const {
+  return true;
+}
+
+void ADVDeviceIdentity::InternalSwap(ADVDeviceIdentity* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.keyindex_)
+      + sizeof(ADVDeviceIdentity::_impl_.keyindex_)
+      - PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.timestamp_)>(
+          reinterpret_cast<char*>(&_impl_.timestamp_),
+          reinterpret_cast<char*>(&other->_impl_.timestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ADVDeviceIdentity::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[0]);
+}
+
+// ===================================================================
+
+class ADVKeyIndexList::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ADVKeyIndexList>()._impl_._has_bits_);
+  static void set_has_rawid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_currentindex(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ADVKeyIndexList::ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ADVKeyIndexList)
+}
+ADVKeyIndexList::ADVKeyIndexList(const ADVKeyIndexList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ADVKeyIndexList* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.validindexes_){from._impl_.validindexes_}
+    , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.timestamp_){}
+    , decltype(_impl_.rawid_){}
+    , decltype(_impl_.currentindex_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.currentindex_) -
+    reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_));
+  // @@protoc_insertion_point(copy_constructor:proto.ADVKeyIndexList)
+}
+
+inline void ADVKeyIndexList::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.validindexes_){arena}
+    , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.timestamp_){uint64_t{0u}}
+    , decltype(_impl_.rawid_){0u}
+    , decltype(_impl_.currentindex_){0u}
+  };
+}
+
+ADVKeyIndexList::~ADVKeyIndexList() {
+  // @@protoc_insertion_point(destructor:proto.ADVKeyIndexList)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ADVKeyIndexList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.validindexes_.~RepeatedField();
+}
+
+void ADVKeyIndexList::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ADVKeyIndexList::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ADVKeyIndexList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.validindexes_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.currentindex_) -
+        reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ADVKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 rawId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_rawid(&has_bits);
+          _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 currentIndex = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_currentindex(&has_bits);
+          _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 validIndexes = 4 [packed = true];
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_validindexes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 32) {
+          _internal_add_validindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ADVKeyIndexList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ADVKeyIndexList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 rawId = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target);
+  }
+
+  // optional uint64 timestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  // optional uint32 currentIndex = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_currentindex(), target);
+  }
+
+  // repeated uint32 validIndexes = 4 [packed = true];
+  {
+    int byte_size = _impl_._validindexes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt32Packed(
+          4, _internal_validindexes(), byte_size, target);
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ADVKeyIndexList)
+  return target;
+}
+
+size_t ADVKeyIndexList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ADVKeyIndexList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated uint32 validIndexes = 4 [packed = true];
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.validindexes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._validindexes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional uint64 timestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp());
+    }
+
+    // optional uint32 rawId = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid());
+    }
+
+    // optional uint32 currentIndex = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVKeyIndexList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ADVKeyIndexList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVKeyIndexList::GetClassData() const { return &_class_data_; }
+
+
+void ADVKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ADVKeyIndexList*>(&to_msg);
+  auto& from = static_cast<const ADVKeyIndexList&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVKeyIndexList)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.validindexes_.MergeFrom(from._impl_.validindexes_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.rawid_ = from._impl_.rawid_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.currentindex_ = from._impl_.currentindex_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ADVKeyIndexList::CopyFrom(const ADVKeyIndexList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVKeyIndexList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ADVKeyIndexList::IsInitialized() const {
+  return true;
+}
+
+void ADVKeyIndexList::InternalSwap(ADVKeyIndexList* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.validindexes_.InternalSwap(&other->_impl_.validindexes_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.currentindex_)
+      + sizeof(ADVKeyIndexList::_impl_.currentindex_)
+      - PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.timestamp_)>(
+          reinterpret_cast<char*>(&_impl_.timestamp_),
+          reinterpret_cast<char*>(&other->_impl_.timestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ADVKeyIndexList::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[1]);
+}
+
+// ===================================================================
+
+class ADVSignedDeviceIdentity::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ADVSignedDeviceIdentity>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_accountsignaturekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_accountsignature(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_devicesignature(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentity)
+}
+ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ADVSignedDeviceIdentity* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.accountsignaturekey_){}
+    , decltype(_impl_.accountsignature_){}
+    , decltype(_impl_.devicesignature_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.accountsignaturekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_accountsignaturekey()) {
+    _this->_impl_.accountsignaturekey_.Set(from._internal_accountsignaturekey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.accountsignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_accountsignature()) {
+    _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.devicesignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.devicesignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_devicesignature()) {
+    _this->_impl_.devicesignature_.Set(from._internal_devicesignature(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentity)
+}
+
+inline void ADVSignedDeviceIdentity::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.accountsignaturekey_){}
+    , decltype(_impl_.accountsignature_){}
+    , decltype(_impl_.devicesignature_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.accountsignaturekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.accountsignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.devicesignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.devicesignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ADVSignedDeviceIdentity::~ADVSignedDeviceIdentity() {
+  // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentity)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ADVSignedDeviceIdentity::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.accountsignaturekey_.Destroy();
+  _impl_.accountsignature_.Destroy();
+  _impl_.devicesignature_.Destroy();
+}
+
+void ADVSignedDeviceIdentity::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ADVSignedDeviceIdentity::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentity)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.accountsignaturekey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.accountsignature_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.devicesignature_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ADVSignedDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes accountSignatureKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_accountsignaturekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes accountSignature = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_accountsignature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes deviceSignature = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_devicesignature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ADVSignedDeviceIdentity::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentity)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes accountSignatureKey = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_accountsignaturekey(), target);
+  }
+
+  // optional bytes accountSignature = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_accountsignature(), target);
+  }
+
+  // optional bytes deviceSignature = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_devicesignature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ADVSignedDeviceIdentity)
+  return target;
+}
+
+size_t ADVSignedDeviceIdentity::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentity)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes accountSignatureKey = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_accountsignaturekey());
+    }
+
+    // optional bytes accountSignature = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_accountsignature());
+    }
+
+    // optional bytes deviceSignature = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_devicesignature());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentity::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ADVSignedDeviceIdentity::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentity::GetClassData() const { return &_class_data_; }
+
+
+void ADVSignedDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ADVSignedDeviceIdentity*>(&to_msg);
+  auto& from = static_cast<const ADVSignedDeviceIdentity&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentity)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_accountsignaturekey(from._internal_accountsignaturekey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_accountsignature(from._internal_accountsignature());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_devicesignature(from._internal_devicesignature());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ADVSignedDeviceIdentity::CopyFrom(const ADVSignedDeviceIdentity& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentity)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ADVSignedDeviceIdentity::IsInitialized() const {
+  return true;
+}
+
+void ADVSignedDeviceIdentity::InternalSwap(ADVSignedDeviceIdentity* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.accountsignaturekey_, lhs_arena,
+      &other->_impl_.accountsignaturekey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.accountsignature_, lhs_arena,
+      &other->_impl_.accountsignature_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.devicesignature_, lhs_arena,
+      &other->_impl_.devicesignature_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentity::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[2]);
+}
+
+// ===================================================================
+
+class ADVSignedDeviceIdentityHMAC::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ADVSignedDeviceIdentityHMAC>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_hmac(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentityHMAC)
+}
+ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ADVSignedDeviceIdentityHMAC* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.hmac_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.hmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_hmac()) {
+    _this->_impl_.hmac_.Set(from._internal_hmac(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentityHMAC)
+}
+
+inline void ADVSignedDeviceIdentityHMAC::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.hmac_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.hmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ADVSignedDeviceIdentityHMAC::~ADVSignedDeviceIdentityHMAC() {
+  // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentityHMAC)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ADVSignedDeviceIdentityHMAC::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.hmac_.Destroy();
+}
+
+void ADVSignedDeviceIdentityHMAC::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ADVSignedDeviceIdentityHMAC::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentityHMAC)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.hmac_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ADVSignedDeviceIdentityHMAC::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes hmac = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_hmac();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ADVSignedDeviceIdentityHMAC::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentityHMAC)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes hmac = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_hmac(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ADVSignedDeviceIdentityHMAC)
+  return target;
+}
+
+size_t ADVSignedDeviceIdentityHMAC::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentityHMAC)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes hmac = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_hmac());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentityHMAC::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ADVSignedDeviceIdentityHMAC::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentityHMAC::GetClassData() const { return &_class_data_; }
+
+
+void ADVSignedDeviceIdentityHMAC::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ADVSignedDeviceIdentityHMAC*>(&to_msg);
+  auto& from = static_cast<const ADVSignedDeviceIdentityHMAC&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentityHMAC)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_hmac(from._internal_hmac());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ADVSignedDeviceIdentityHMAC::CopyFrom(const ADVSignedDeviceIdentityHMAC& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentityHMAC)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ADVSignedDeviceIdentityHMAC::IsInitialized() const {
+  return true;
+}
+
+void ADVSignedDeviceIdentityHMAC::InternalSwap(ADVSignedDeviceIdentityHMAC* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hmac_, lhs_arena,
+      &other->_impl_.hmac_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentityHMAC::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[3]);
+}
+
+// ===================================================================
+
+class ADVSignedKeyIndexList::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ADVSignedKeyIndexList>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_accountsignature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ADVSignedKeyIndexList::ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ADVSignedKeyIndexList)
+}
+ADVSignedKeyIndexList::ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ADVSignedKeyIndexList* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.accountsignature_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.accountsignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_accountsignature()) {
+    _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ADVSignedKeyIndexList)
+}
+
+inline void ADVSignedKeyIndexList::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.accountsignature_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.accountsignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ADVSignedKeyIndexList::~ADVSignedKeyIndexList() {
+  // @@protoc_insertion_point(destructor:proto.ADVSignedKeyIndexList)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ADVSignedKeyIndexList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.accountsignature_.Destroy();
+}
+
+void ADVSignedKeyIndexList::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ADVSignedKeyIndexList::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ADVSignedKeyIndexList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.accountsignature_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ADVSignedKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes accountSignature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_accountsignature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ADVSignedKeyIndexList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedKeyIndexList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes accountSignature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_accountsignature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ADVSignedKeyIndexList)
+  return target;
+}
+
+size_t ADVSignedKeyIndexList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedKeyIndexList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes accountSignature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_accountsignature());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedKeyIndexList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ADVSignedKeyIndexList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedKeyIndexList::GetClassData() const { return &_class_data_; }
+
+
+void ADVSignedKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ADVSignedKeyIndexList*>(&to_msg);
+  auto& from = static_cast<const ADVSignedKeyIndexList&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedKeyIndexList)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_accountsignature(from._internal_accountsignature());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ADVSignedKeyIndexList::CopyFrom(const ADVSignedKeyIndexList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedKeyIndexList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ADVSignedKeyIndexList::IsInitialized() const {
+  return true;
+}
+
+void ADVSignedKeyIndexList::InternalSwap(ADVSignedKeyIndexList* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.accountsignature_, lhs_arena,
+      &other->_impl_.accountsignature_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedKeyIndexList::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[4]);
+}
+
+// ===================================================================
+
+class ActionLink::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ActionLink>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_buttontitle(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ActionLink::ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ActionLink)
+}
+ActionLink::ActionLink(const ActionLink& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ActionLink* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.buttontitle_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.buttontitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttontitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_buttontitle()) {
+    _this->_impl_.buttontitle_.Set(from._internal_buttontitle(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ActionLink)
+}
+
+inline void ActionLink::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.buttontitle_){}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.buttontitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttontitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ActionLink::~ActionLink() {
+  // @@protoc_insertion_point(destructor:proto.ActionLink)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ActionLink::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.buttontitle_.Destroy();
+}
+
+void ActionLink::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ActionLink::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ActionLink)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.buttontitle_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ActionLink::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ActionLink.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string buttonTitle = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_buttontitle();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ActionLink.buttonTitle");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ActionLink::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ActionLink)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ActionLink.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string buttonTitle = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_buttontitle().data(), static_cast<int>(this->_internal_buttontitle().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ActionLink.buttonTitle");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_buttontitle(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ActionLink)
+  return target;
+}
+
+size_t ActionLink::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ActionLink)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string buttonTitle = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_buttontitle());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ActionLink::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ActionLink::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ActionLink::GetClassData() const { return &_class_data_; }
+
+
+void ActionLink::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ActionLink*>(&to_msg);
+  auto& from = static_cast<const ActionLink&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ActionLink)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_buttontitle(from._internal_buttontitle());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ActionLink::CopyFrom(const ActionLink& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ActionLink)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ActionLink::IsInitialized() const {
+  return true;
+}
+
+void ActionLink::InternalSwap(ActionLink* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.buttontitle_, lhs_arena,
+      &other->_impl_.buttontitle_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ActionLink::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[5]);
+}
+
+// ===================================================================
+
+class AutoDownloadSettings::_Internal {
+ public:
+  using HasBits = decltype(std::declval<AutoDownloadSettings>()._impl_._has_bits_);
+  static void set_has_downloadimages(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_downloadaudio(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_downloadvideo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_downloaddocuments(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+AutoDownloadSettings::AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.AutoDownloadSettings)
+}
+AutoDownloadSettings::AutoDownloadSettings(const AutoDownloadSettings& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  AutoDownloadSettings* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.downloadimages_){}
+    , decltype(_impl_.downloadaudio_){}
+    , decltype(_impl_.downloadvideo_){}
+    , decltype(_impl_.downloaddocuments_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.downloadimages_, &from._impl_.downloadimages_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.downloaddocuments_) -
+    reinterpret_cast<char*>(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_));
+  // @@protoc_insertion_point(copy_constructor:proto.AutoDownloadSettings)
+}
+
+inline void AutoDownloadSettings::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.downloadimages_){false}
+    , decltype(_impl_.downloadaudio_){false}
+    , decltype(_impl_.downloadvideo_){false}
+    , decltype(_impl_.downloaddocuments_){false}
+  };
+}
+
+AutoDownloadSettings::~AutoDownloadSettings() {
+  // @@protoc_insertion_point(destructor:proto.AutoDownloadSettings)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void AutoDownloadSettings::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void AutoDownloadSettings::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void AutoDownloadSettings::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.AutoDownloadSettings)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.downloadimages_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.downloaddocuments_) -
+      reinterpret_cast<char*>(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_));
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AutoDownloadSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool downloadImages = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_downloadimages(&has_bits);
+          _impl_.downloadimages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool downloadAudio = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_downloadaudio(&has_bits);
+          _impl_.downloadaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool downloadVideo = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_downloadvideo(&has_bits);
+          _impl_.downloadvideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool downloadDocuments = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_downloaddocuments(&has_bits);
+          _impl_.downloaddocuments_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AutoDownloadSettings::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.AutoDownloadSettings)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool downloadImages = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_downloadimages(), target);
+  }
+
+  // optional bool downloadAudio = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_downloadaudio(), target);
+  }
+
+  // optional bool downloadVideo = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_downloadvideo(), target);
+  }
+
+  // optional bool downloadDocuments = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_downloaddocuments(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.AutoDownloadSettings)
+  return target;
+}
+
+size_t AutoDownloadSettings::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.AutoDownloadSettings)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bool downloadImages = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool downloadAudio = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool downloadVideo = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool downloadDocuments = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AutoDownloadSettings::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    AutoDownloadSettings::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AutoDownloadSettings::GetClassData() const { return &_class_data_; }
+
+
+void AutoDownloadSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<AutoDownloadSettings*>(&to_msg);
+  auto& from = static_cast<const AutoDownloadSettings&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.AutoDownloadSettings)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.downloadimages_ = from._impl_.downloadimages_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.downloadaudio_ = from._impl_.downloadaudio_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.downloadvideo_ = from._impl_.downloadvideo_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.downloaddocuments_ = from._impl_.downloaddocuments_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AutoDownloadSettings::CopyFrom(const AutoDownloadSettings& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.AutoDownloadSettings)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AutoDownloadSettings::IsInitialized() const {
+  return true;
+}
+
+void AutoDownloadSettings::InternalSwap(AutoDownloadSettings* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloaddocuments_)
+      + sizeof(AutoDownloadSettings::_impl_.downloaddocuments_)
+      - PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloadimages_)>(
+          reinterpret_cast<char*>(&_impl_.downloadimages_),
+          reinterpret_cast<char*>(&other->_impl_.downloadimages_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AutoDownloadSettings::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[6]);
+}
+
+// ===================================================================
+
+class BizAccountLinkInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<BizAccountLinkInfo>()._impl_._has_bits_);
+  static void set_has_whatsappbizacctfbid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_whatsappacctnumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_issuetime(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_hoststorage(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_accounttype(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+BizAccountLinkInfo::BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.BizAccountLinkInfo)
+}
+BizAccountLinkInfo::BizAccountLinkInfo(const BizAccountLinkInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  BizAccountLinkInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.whatsappacctnumber_){}
+    , decltype(_impl_.whatsappbizacctfbid_){}
+    , decltype(_impl_.issuetime_){}
+    , decltype(_impl_.hoststorage_){}
+    , decltype(_impl_.accounttype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.whatsappacctnumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_whatsappacctnumber()) {
+    _this->_impl_.whatsappacctnumber_.Set(from._internal_whatsappacctnumber(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.whatsappbizacctfbid_, &from._impl_.whatsappbizacctfbid_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.accounttype_) -
+    reinterpret_cast<char*>(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_));
+  // @@protoc_insertion_point(copy_constructor:proto.BizAccountLinkInfo)
+}
+
+inline void BizAccountLinkInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.whatsappacctnumber_){}
+    , decltype(_impl_.whatsappbizacctfbid_){uint64_t{0u}}
+    , decltype(_impl_.issuetime_){uint64_t{0u}}
+    , decltype(_impl_.hoststorage_){0}
+    , decltype(_impl_.accounttype_){0}
+  };
+  _impl_.whatsappacctnumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+BizAccountLinkInfo::~BizAccountLinkInfo() {
+  // @@protoc_insertion_point(destructor:proto.BizAccountLinkInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void BizAccountLinkInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.whatsappacctnumber_.Destroy();
+}
+
+void BizAccountLinkInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void BizAccountLinkInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.BizAccountLinkInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.whatsappacctnumber_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000001eu) {
+    ::memset(&_impl_.whatsappbizacctfbid_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.accounttype_) -
+        reinterpret_cast<char*>(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* BizAccountLinkInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 whatsappBizAcctFbid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_whatsappbizacctfbid(&has_bits);
+          _impl_.whatsappbizacctfbid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string whatsappAcctNumber = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_whatsappacctnumber();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.BizAccountLinkInfo.whatsappAcctNumber");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 issueTime = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_issuetime(&has_bits);
+          _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_HostStorageType_IsValid(val))) {
+            _internal_set_hoststorage(static_cast<::proto::BizAccountLinkInfo_HostStorageType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_AccountType_IsValid(val))) {
+            _internal_set_accounttype(static_cast<::proto::BizAccountLinkInfo_AccountType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* BizAccountLinkInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountLinkInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 whatsappBizAcctFbid = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_whatsappbizacctfbid(), target);
+  }
+
+  // optional string whatsappAcctNumber = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_whatsappacctnumber().data(), static_cast<int>(this->_internal_whatsappacctnumber().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.BizAccountLinkInfo.whatsappAcctNumber");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_whatsappacctnumber(), target);
+  }
+
+  // optional uint64 issueTime = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_issuetime(), target);
+  }
+
+  // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_hoststorage(), target);
+  }
+
+  // optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_accounttype(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.BizAccountLinkInfo)
+  return target;
+}
+
+size_t BizAccountLinkInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountLinkInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string whatsappAcctNumber = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_whatsappacctnumber());
+    }
+
+    // optional uint64 whatsappBizAcctFbid = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_whatsappbizacctfbid());
+    }
+
+    // optional uint64 issueTime = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime());
+    }
+
+    // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage());
+    }
+
+    // optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_accounttype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountLinkInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    BizAccountLinkInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountLinkInfo::GetClassData() const { return &_class_data_; }
+
+
+void BizAccountLinkInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<BizAccountLinkInfo*>(&to_msg);
+  auto& from = static_cast<const BizAccountLinkInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountLinkInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_whatsappacctnumber(from._internal_whatsappacctnumber());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.whatsappbizacctfbid_ = from._impl_.whatsappbizacctfbid_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.issuetime_ = from._impl_.issuetime_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.hoststorage_ = from._impl_.hoststorage_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.accounttype_ = from._impl_.accounttype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void BizAccountLinkInfo::CopyFrom(const BizAccountLinkInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountLinkInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BizAccountLinkInfo::IsInitialized() const {
+  return true;
+}
+
+void BizAccountLinkInfo::InternalSwap(BizAccountLinkInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.whatsappacctnumber_, lhs_arena,
+      &other->_impl_.whatsappacctnumber_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.accounttype_)
+      + sizeof(BizAccountLinkInfo::_impl_.accounttype_)
+      - PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.whatsappbizacctfbid_)>(
+          reinterpret_cast<char*>(&_impl_.whatsappbizacctfbid_),
+          reinterpret_cast<char*>(&other->_impl_.whatsappbizacctfbid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BizAccountLinkInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[7]);
+}
+
+// ===================================================================
+
+class BizAccountPayload::_Internal {
+ public:
+  using HasBits = decltype(std::declval<BizAccountPayload>()._impl_._has_bits_);
+  static const ::proto::VerifiedNameCertificate& vnamecert(const BizAccountPayload* msg);
+  static void set_has_vnamecert(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_bizacctlinkinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::VerifiedNameCertificate&
+BizAccountPayload::_Internal::vnamecert(const BizAccountPayload* msg) {
+  return *msg->_impl_.vnamecert_;
+}
+BizAccountPayload::BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.BizAccountPayload)
+}
+BizAccountPayload::BizAccountPayload(const BizAccountPayload& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  BizAccountPayload* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bizacctlinkinfo_){}
+    , decltype(_impl_.vnamecert_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.bizacctlinkinfo_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bizacctlinkinfo()) {
+    _this->_impl_.bizacctlinkinfo_.Set(from._internal_bizacctlinkinfo(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_vnamecert()) {
+    _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.BizAccountPayload)
+}
+
+inline void BizAccountPayload::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bizacctlinkinfo_){}
+    , decltype(_impl_.vnamecert_){nullptr}
+  };
+  _impl_.bizacctlinkinfo_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+BizAccountPayload::~BizAccountPayload() {
+  // @@protoc_insertion_point(destructor:proto.BizAccountPayload)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void BizAccountPayload::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.bizacctlinkinfo_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.vnamecert_;
+}
+
+void BizAccountPayload::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void BizAccountPayload::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.BizAccountPayload)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.bizacctlinkinfo_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr);
+      _impl_.vnamecert_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* BizAccountPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.VerifiedNameCertificate vnameCert = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes bizAcctLinkInfo = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_bizacctlinkinfo();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* BizAccountPayload::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountPayload)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.VerifiedNameCertificate vnameCert = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::vnamecert(this),
+        _Internal::vnamecert(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes bizAcctLinkInfo = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_bizacctlinkinfo(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.BizAccountPayload)
+  return target;
+}
+
+size_t BizAccountPayload::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountPayload)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes bizAcctLinkInfo = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_bizacctlinkinfo());
+    }
+
+    // optional .proto.VerifiedNameCertificate vnameCert = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.vnamecert_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountPayload::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    BizAccountPayload::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountPayload::GetClassData() const { return &_class_data_; }
+
+
+void BizAccountPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<BizAccountPayload*>(&to_msg);
+  auto& from = static_cast<const BizAccountPayload&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountPayload)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_bizacctlinkinfo(from._internal_bizacctlinkinfo());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom(
+          from._internal_vnamecert());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void BizAccountPayload::CopyFrom(const BizAccountPayload& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountPayload)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BizAccountPayload::IsInitialized() const {
+  return true;
+}
+
+void BizAccountPayload::InternalSwap(BizAccountPayload* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bizacctlinkinfo_, lhs_arena,
+      &other->_impl_.bizacctlinkinfo_, rhs_arena
+  );
+  swap(_impl_.vnamecert_, other->_impl_.vnamecert_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BizAccountPayload::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[8]);
+}
+
+// ===================================================================
+
+class BizIdentityInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<BizIdentityInfo>()._impl_._has_bits_);
+  static void set_has_vlevel(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::VerifiedNameCertificate& vnamecert(const BizIdentityInfo* msg);
+  static void set_has_vnamecert(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_signed_(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_revoked(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_hoststorage(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_actualactors(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_privacymodets(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_featurecontrols(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+const ::proto::VerifiedNameCertificate&
+BizIdentityInfo::_Internal::vnamecert(const BizIdentityInfo* msg) {
+  return *msg->_impl_.vnamecert_;
+}
+BizIdentityInfo::BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.BizIdentityInfo)
+}
+BizIdentityInfo::BizIdentityInfo(const BizIdentityInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  BizIdentityInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.vnamecert_){nullptr}
+    , decltype(_impl_.vlevel_){}
+    , decltype(_impl_.signed__){}
+    , decltype(_impl_.revoked_){}
+    , decltype(_impl_.hoststorage_){}
+    , decltype(_impl_.actualactors_){}
+    , decltype(_impl_.privacymodets_){}
+    , decltype(_impl_.featurecontrols_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_vnamecert()) {
+    _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_);
+  }
+  ::memcpy(&_impl_.vlevel_, &from._impl_.vlevel_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.featurecontrols_) -
+    reinterpret_cast<char*>(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_));
+  // @@protoc_insertion_point(copy_constructor:proto.BizIdentityInfo)
+}
+
+inline void BizIdentityInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.vnamecert_){nullptr}
+    , decltype(_impl_.vlevel_){0}
+    , decltype(_impl_.signed__){false}
+    , decltype(_impl_.revoked_){false}
+    , decltype(_impl_.hoststorage_){0}
+    , decltype(_impl_.actualactors_){0}
+    , decltype(_impl_.privacymodets_){uint64_t{0u}}
+    , decltype(_impl_.featurecontrols_){uint64_t{0u}}
+  };
+}
+
+BizIdentityInfo::~BizIdentityInfo() {
+  // @@protoc_insertion_point(destructor:proto.BizIdentityInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void BizIdentityInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.vnamecert_;
+}
+
+void BizIdentityInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void BizIdentityInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.BizIdentityInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr);
+    _impl_.vnamecert_->Clear();
+  }
+  if (cached_has_bits & 0x000000feu) {
+    ::memset(&_impl_.vlevel_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.featurecontrols_) -
+        reinterpret_cast<char*>(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* BizIdentityInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(val))) {
+            _internal_set_vlevel(static_cast<::proto::BizIdentityInfo_VerifiedLevelValue>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.VerifiedNameCertificate vnameCert = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool signed = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_signed_(&has_bits);
+          _impl_.signed__ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool revoked = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_revoked(&has_bits);
+          _impl_.revoked_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_HostStorageType_IsValid(val))) {
+            _internal_set_hoststorage(static_cast<::proto::BizIdentityInfo_HostStorageType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_ActualActorsType_IsValid(val))) {
+            _internal_set_actualactors(static_cast<::proto::BizIdentityInfo_ActualActorsType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 privacyModeTs = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_privacymodets(&has_bits);
+          _impl_.privacymodets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 featureControls = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_featurecontrols(&has_bits);
+          _impl_.featurecontrols_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* BizIdentityInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.BizIdentityInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_vlevel(), target);
+  }
+
+  // optional .proto.VerifiedNameCertificate vnameCert = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::vnamecert(this),
+        _Internal::vnamecert(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool signed = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_signed_(), target);
+  }
+
+  // optional bool revoked = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_revoked(), target);
+  }
+
+  // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_hoststorage(), target);
+  }
+
+  // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      6, this->_internal_actualactors(), target);
+  }
+
+  // optional uint64 privacyModeTs = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_privacymodets(), target);
+  }
+
+  // optional uint64 featureControls = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_featurecontrols(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.BizIdentityInfo)
+  return target;
+}
+
+size_t BizIdentityInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.BizIdentityInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.VerifiedNameCertificate vnameCert = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.vnamecert_);
+    }
+
+    // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_vlevel());
+    }
+
+    // optional bool signed = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool revoked = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+    // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage());
+    }
+
+    // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_actualactors());
+    }
+
+    // optional uint64 privacyModeTs = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_privacymodets());
+    }
+
+    // optional uint64 featureControls = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_featurecontrols());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizIdentityInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    BizIdentityInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizIdentityInfo::GetClassData() const { return &_class_data_; }
+
+
+void BizIdentityInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<BizIdentityInfo*>(&to_msg);
+  auto& from = static_cast<const BizIdentityInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizIdentityInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom(
+          from._internal_vnamecert());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.vlevel_ = from._impl_.vlevel_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.signed__ = from._impl_.signed__;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.revoked_ = from._impl_.revoked_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.hoststorage_ = from._impl_.hoststorage_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.actualactors_ = from._impl_.actualactors_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.privacymodets_ = from._impl_.privacymodets_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.featurecontrols_ = from._impl_.featurecontrols_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void BizIdentityInfo::CopyFrom(const BizIdentityInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizIdentityInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BizIdentityInfo::IsInitialized() const {
+  return true;
+}
+
+void BizIdentityInfo::InternalSwap(BizIdentityInfo* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.featurecontrols_)
+      + sizeof(BizIdentityInfo::_impl_.featurecontrols_)
+      - PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.vnamecert_)>(
+          reinterpret_cast<char*>(&_impl_.vnamecert_),
+          reinterpret_cast<char*>(&other->_impl_.vnamecert_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BizIdentityInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[9]);
+}
+
+// ===================================================================
+
+class CertChain_NoiseCertificate_Details::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CertChain_NoiseCertificate_Details>()._impl_._has_bits_);
+  static void set_has_serial(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_issuerserial(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_notbefore(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_notafter(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate.Details)
+}
+CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CertChain_NoiseCertificate_Details* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.serial_){}
+    , decltype(_impl_.issuerserial_){}
+    , decltype(_impl_.notbefore_){}
+    , decltype(_impl_.notafter_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_key()) {
+    _this->_impl_.key_.Set(from._internal_key(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.serial_, &from._impl_.serial_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.notafter_) -
+    reinterpret_cast<char*>(&_impl_.serial_)) + sizeof(_impl_.notafter_));
+  // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate.Details)
+}
+
+inline void CertChain_NoiseCertificate_Details::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.serial_){0u}
+    , decltype(_impl_.issuerserial_){0u}
+    , decltype(_impl_.notbefore_){uint64_t{0u}}
+    , decltype(_impl_.notafter_){uint64_t{0u}}
+  };
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+CertChain_NoiseCertificate_Details::~CertChain_NoiseCertificate_Details() {
+  // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate.Details)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CertChain_NoiseCertificate_Details::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.key_.Destroy();
+}
+
+void CertChain_NoiseCertificate_Details::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CertChain_NoiseCertificate_Details::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.key_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000001eu) {
+    ::memset(&_impl_.serial_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.notafter_) -
+        reinterpret_cast<char*>(&_impl_.serial_)) + sizeof(_impl_.notafter_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CertChain_NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 serial = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_serial(&has_bits);
+          _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 issuerSerial = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_issuerserial(&has_bits);
+          _impl_.issuerserial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes key = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_key();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 notBefore = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_notbefore(&has_bits);
+          _impl_.notbefore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 notAfter = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_notafter(&has_bits);
+          _impl_.notafter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CertChain_NoiseCertificate_Details::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 serial = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target);
+  }
+
+  // optional uint32 issuerSerial = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_issuerserial(), target);
+  }
+
+  // optional bytes key = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_key(), target);
+  }
+
+  // optional uint64 notBefore = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_notbefore(), target);
+  }
+
+  // optional uint64 notAfter = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_notafter(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.CertChain.NoiseCertificate.Details)
+  return target;
+}
+
+size_t CertChain_NoiseCertificate_Details::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate.Details)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes key = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_key());
+    }
+
+    // optional uint32 serial = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial());
+    }
+
+    // optional uint32 issuerSerial = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_issuerserial());
+    }
+
+    // optional uint64 notBefore = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notbefore());
+    }
+
+    // optional uint64 notAfter = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notafter());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate_Details::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CertChain_NoiseCertificate_Details::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate_Details::GetClassData() const { return &_class_data_; }
+
+
+void CertChain_NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CertChain_NoiseCertificate_Details*>(&to_msg);
+  auto& from = static_cast<const CertChain_NoiseCertificate_Details&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate.Details)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_key(from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.serial_ = from._impl_.serial_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.issuerserial_ = from._impl_.issuerserial_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.notbefore_ = from._impl_.notbefore_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.notafter_ = from._impl_.notafter_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CertChain_NoiseCertificate_Details::CopyFrom(const CertChain_NoiseCertificate_Details& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate.Details)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CertChain_NoiseCertificate_Details::IsInitialized() const {
+  return true;
+}
+
+void CertChain_NoiseCertificate_Details::InternalSwap(CertChain_NoiseCertificate_Details* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.key_, lhs_arena,
+      &other->_impl_.key_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.notafter_)
+      + sizeof(CertChain_NoiseCertificate_Details::_impl_.notafter_)
+      - PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.serial_)>(
+          reinterpret_cast<char*>(&_impl_.serial_),
+          reinterpret_cast<char*>(&other->_impl_.serial_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate_Details::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[10]);
+}
+
+// ===================================================================
+
+class CertChain_NoiseCertificate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CertChain_NoiseCertificate>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+CertChain_NoiseCertificate::CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate)
+}
+CertChain_NoiseCertificate::CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CertChain_NoiseCertificate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_.Set(from._internal_signature(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate)
+}
+
+inline void CertChain_NoiseCertificate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+CertChain_NoiseCertificate::~CertChain_NoiseCertificate() {
+  // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CertChain_NoiseCertificate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.signature_.Destroy();
+}
+
+void CertChain_NoiseCertificate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CertChain_NoiseCertificate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.signature_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CertChain_NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes signature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_signature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CertChain_NoiseCertificate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes signature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_signature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.CertChain.NoiseCertificate)
+  return target;
+}
+
+size_t CertChain_NoiseCertificate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes signature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_signature());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CertChain_NoiseCertificate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate::GetClassData() const { return &_class_data_; }
+
+
+void CertChain_NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CertChain_NoiseCertificate*>(&to_msg);
+  auto& from = static_cast<const CertChain_NoiseCertificate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_signature(from._internal_signature());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CertChain_NoiseCertificate::CopyFrom(const CertChain_NoiseCertificate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CertChain_NoiseCertificate::IsInitialized() const {
+  return true;
+}
+
+void CertChain_NoiseCertificate::InternalSwap(CertChain_NoiseCertificate* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.signature_, lhs_arena,
+      &other->_impl_.signature_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[11]);
+}
+
+// ===================================================================
+
+class CertChain::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CertChain>()._impl_._has_bits_);
+  static const ::proto::CertChain_NoiseCertificate& leaf(const CertChain* msg);
+  static void set_has_leaf(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::CertChain_NoiseCertificate& intermediate(const CertChain* msg);
+  static void set_has_intermediate(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::CertChain_NoiseCertificate&
+CertChain::_Internal::leaf(const CertChain* msg) {
+  return *msg->_impl_.leaf_;
+}
+const ::proto::CertChain_NoiseCertificate&
+CertChain::_Internal::intermediate(const CertChain* msg) {
+  return *msg->_impl_.intermediate_;
+}
+CertChain::CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.CertChain)
+}
+CertChain::CertChain(const CertChain& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CertChain* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.leaf_){nullptr}
+    , decltype(_impl_.intermediate_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_leaf()) {
+    _this->_impl_.leaf_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.leaf_);
+  }
+  if (from._internal_has_intermediate()) {
+    _this->_impl_.intermediate_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.intermediate_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.CertChain)
+}
+
+inline void CertChain::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.leaf_){nullptr}
+    , decltype(_impl_.intermediate_){nullptr}
+  };
+}
+
+CertChain::~CertChain() {
+  // @@protoc_insertion_point(destructor:proto.CertChain)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CertChain::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.leaf_;
+  if (this != internal_default_instance()) delete _impl_.intermediate_;
+}
+
+void CertChain::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CertChain::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.CertChain)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.leaf_ != nullptr);
+      _impl_.leaf_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.intermediate_ != nullptr);
+      _impl_.intermediate_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CertChain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.CertChain.NoiseCertificate leaf = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_leaf(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.CertChain.NoiseCertificate intermediate = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_intermediate(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CertChain::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.CertChain.NoiseCertificate leaf = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::leaf(this),
+        _Internal::leaf(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.CertChain.NoiseCertificate intermediate = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::intermediate(this),
+        _Internal::intermediate(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.CertChain)
+  return target;
+}
+
+size_t CertChain::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.CertChain)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.CertChain.NoiseCertificate leaf = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.leaf_);
+    }
+
+    // optional .proto.CertChain.NoiseCertificate intermediate = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.intermediate_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CertChain::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain::GetClassData() const { return &_class_data_; }
+
+
+void CertChain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CertChain*>(&to_msg);
+  auto& from = static_cast<const CertChain&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_leaf()->::proto::CertChain_NoiseCertificate::MergeFrom(
+          from._internal_leaf());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_intermediate()->::proto::CertChain_NoiseCertificate::MergeFrom(
+          from._internal_intermediate());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CertChain::CopyFrom(const CertChain& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CertChain::IsInitialized() const {
+  return true;
+}
+
+void CertChain::InternalSwap(CertChain* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CertChain, _impl_.intermediate_)
+      + sizeof(CertChain::_impl_.intermediate_)
+      - PROTOBUF_FIELD_OFFSET(CertChain, _impl_.leaf_)>(
+          reinterpret_cast<char*>(&_impl_.leaf_),
+          reinterpret_cast<char*>(&other->_impl_.leaf_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CertChain::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[12]);
+}
+
+// ===================================================================
+
+class Chain::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Chain>()._impl_._has_bits_);
+  static void set_has_senderratchetkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_senderratchetkeyprivate(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ChainKey& chainkey(const Chain* msg);
+  static void set_has_chainkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::ChainKey&
+Chain::_Internal::chainkey(const Chain* msg) {
+  return *msg->_impl_.chainkey_;
+}
+Chain::Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Chain)
+}
+Chain::Chain(const Chain& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Chain* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagekeys_){from._impl_.messagekeys_}
+    , decltype(_impl_.senderratchetkey_){}
+    , decltype(_impl_.senderratchetkeyprivate_){}
+    , decltype(_impl_.chainkey_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.senderratchetkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_senderratchetkey()) {
+    _this->_impl_.senderratchetkey_.Set(from._internal_senderratchetkey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.senderratchetkeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_senderratchetkeyprivate()) {
+    _this->_impl_.senderratchetkeyprivate_.Set(from._internal_senderratchetkeyprivate(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_chainkey()) {
+    _this->_impl_.chainkey_ = new ::proto::ChainKey(*from._impl_.chainkey_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Chain)
+}
+
+inline void Chain::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagekeys_){arena}
+    , decltype(_impl_.senderratchetkey_){}
+    , decltype(_impl_.senderratchetkeyprivate_){}
+    , decltype(_impl_.chainkey_){nullptr}
+  };
+  _impl_.senderratchetkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.senderratchetkeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Chain::~Chain() {
+  // @@protoc_insertion_point(destructor:proto.Chain)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Chain::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.messagekeys_.~RepeatedPtrField();
+  _impl_.senderratchetkey_.Destroy();
+  _impl_.senderratchetkeyprivate_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.chainkey_;
+}
+
+void Chain::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Chain::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Chain)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.messagekeys_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.senderratchetkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.senderratchetkeyprivate_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.chainkey_ != nullptr);
+      _impl_.chainkey_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Chain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes senderRatchetKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_senderratchetkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes senderRatchetKeyPrivate = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_senderratchetkeyprivate();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ChainKey chainKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_chainkey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.MessageKey messageKeys = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_messagekeys(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Chain::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Chain)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes senderRatchetKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_senderratchetkey(), target);
+  }
+
+  // optional bytes senderRatchetKeyPrivate = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_senderratchetkeyprivate(), target);
+  }
+
+  // optional .proto.ChainKey chainKey = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::chainkey(this),
+        _Internal::chainkey(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.MessageKey messageKeys = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_messagekeys_size()); i < n; i++) {
+    const auto& repfield = this->_internal_messagekeys(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Chain)
+  return target;
+}
+
+size_t Chain::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Chain)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.MessageKey messageKeys = 4;
+  total_size += 1UL * this->_internal_messagekeys_size();
+  for (const auto& msg : this->_impl_.messagekeys_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes senderRatchetKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_senderratchetkey());
+    }
+
+    // optional bytes senderRatchetKeyPrivate = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_senderratchetkeyprivate());
+    }
+
+    // optional .proto.ChainKey chainKey = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.chainkey_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Chain::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Chain::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Chain::GetClassData() const { return &_class_data_; }
+
+
+void Chain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Chain*>(&to_msg);
+  auto& from = static_cast<const Chain&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Chain)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.messagekeys_.MergeFrom(from._impl_.messagekeys_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_senderratchetkey(from._internal_senderratchetkey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_senderratchetkeyprivate(from._internal_senderratchetkeyprivate());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_chainkey()->::proto::ChainKey::MergeFrom(
+          from._internal_chainkey());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Chain::CopyFrom(const Chain& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Chain)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Chain::IsInitialized() const {
+  return true;
+}
+
+void Chain::InternalSwap(Chain* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.messagekeys_.InternalSwap(&other->_impl_.messagekeys_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.senderratchetkey_, lhs_arena,
+      &other->_impl_.senderratchetkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.senderratchetkeyprivate_, lhs_arena,
+      &other->_impl_.senderratchetkeyprivate_, rhs_arena
+  );
+  swap(_impl_.chainkey_, other->_impl_.chainkey_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Chain::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[13]);
+}
+
+// ===================================================================
+
+class ChainKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ChainKey>()._impl_._has_bits_);
+  static void set_has_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ChainKey::ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ChainKey)
+}
+ChainKey::ChainKey(const ChainKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ChainKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.index_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_key()) {
+    _this->_impl_.key_.Set(from._internal_key(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.index_ = from._impl_.index_;
+  // @@protoc_insertion_point(copy_constructor:proto.ChainKey)
+}
+
+inline void ChainKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.index_){0u}
+  };
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ChainKey::~ChainKey() {
+  // @@protoc_insertion_point(destructor:proto.ChainKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ChainKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.key_.Destroy();
+}
+
+void ChainKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ChainKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ChainKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.key_.ClearNonDefaultToEmpty();
+  }
+  _impl_.index_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 index = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_index(&has_bits);
+          _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes key = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_key();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ChainKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ChainKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 index = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target);
+  }
+
+  // optional bytes key = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_key(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ChainKey)
+  return target;
+}
+
+size_t ChainKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ChainKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes key = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_key());
+    }
+
+    // optional uint32 index = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChainKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ChainKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChainKey::GetClassData() const { return &_class_data_; }
+
+
+void ChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ChainKey*>(&to_msg);
+  auto& from = static_cast<const ChainKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ChainKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_key(from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.index_ = from._impl_.index_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ChainKey::CopyFrom(const ChainKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ChainKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChainKey::IsInitialized() const {
+  return true;
+}
+
+void ChainKey::InternalSwap(ChainKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.key_, lhs_arena,
+      &other->_impl_.key_, rhs_arena
+  );
+  swap(_impl_.index_, other->_impl_.index_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ChainKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[14]);
+}
+
+// ===================================================================
+
+class ClientPayload_DNSSource::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_DNSSource>()._impl_._has_bits_);
+  static void set_has_dnsmethod(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_appcached(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientPayload_DNSSource::ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DNSSource)
+}
+ClientPayload_DNSSource::ClientPayload_DNSSource(const ClientPayload_DNSSource& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_DNSSource* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.dnsmethod_){}
+    , decltype(_impl_.appcached_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.dnsmethod_, &from._impl_.dnsmethod_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.appcached_) -
+    reinterpret_cast<char*>(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_));
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DNSSource)
+}
+
+inline void ClientPayload_DNSSource::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.dnsmethod_){0}
+    , decltype(_impl_.appcached_){false}
+  };
+}
+
+ClientPayload_DNSSource::~ClientPayload_DNSSource() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.DNSSource)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_DNSSource::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ClientPayload_DNSSource::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_DNSSource::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DNSSource)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.dnsmethod_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.appcached_) -
+        reinterpret_cast<char*>(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_DNSSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(val))) {
+            _internal_set_dnsmethod(static_cast<::proto::ClientPayload_DNSSource_DNSResolutionMethod>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool appCached = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_appcached(&has_bits);
+          _impl_.appcached_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_DNSSource::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DNSSource)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      15, this->_internal_dnsmethod(), target);
+  }
+
+  // optional bool appCached = 16;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_appcached(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.DNSSource)
+  return target;
+}
+
+size_t ClientPayload_DNSSource::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DNSSource)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_dnsmethod());
+    }
+
+    // optional bool appCached = 16;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DNSSource::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_DNSSource::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DNSSource::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_DNSSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_DNSSource*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_DNSSource&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DNSSource)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.dnsmethod_ = from._impl_.dnsmethod_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.appcached_ = from._impl_.appcached_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_DNSSource::CopyFrom(const ClientPayload_DNSSource& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DNSSource)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_DNSSource::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_DNSSource::InternalSwap(ClientPayload_DNSSource* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.appcached_)
+      + sizeof(ClientPayload_DNSSource::_impl_.appcached_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.dnsmethod_)>(
+          reinterpret_cast<char*>(&_impl_.dnsmethod_),
+          reinterpret_cast<char*>(&other->_impl_.dnsmethod_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DNSSource::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[15]);
+}
+
+// ===================================================================
+
+class ClientPayload_DevicePairingRegistrationData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_DevicePairingRegistrationData>()._impl_._has_bits_);
+  static void set_has_eregid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_ekeytype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_eident(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_eskeyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_eskeyval(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_eskeysig(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_buildhash(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_deviceprops(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DevicePairingRegistrationData)
+}
+ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_DevicePairingRegistrationData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.eregid_){}
+    , decltype(_impl_.ekeytype_){}
+    , decltype(_impl_.eident_){}
+    , decltype(_impl_.eskeyid_){}
+    , decltype(_impl_.eskeyval_){}
+    , decltype(_impl_.eskeysig_){}
+    , decltype(_impl_.buildhash_){}
+    , decltype(_impl_.deviceprops_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.eregid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eregid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_eregid()) {
+    _this->_impl_.eregid_.Set(from._internal_eregid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.ekeytype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ekeytype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ekeytype()) {
+    _this->_impl_.ekeytype_.Set(from._internal_ekeytype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.eident_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eident_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_eident()) {
+    _this->_impl_.eident_.Set(from._internal_eident(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.eskeyid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeyid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_eskeyid()) {
+    _this->_impl_.eskeyid_.Set(from._internal_eskeyid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.eskeyval_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeyval_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_eskeyval()) {
+    _this->_impl_.eskeyval_.Set(from._internal_eskeyval(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.eskeysig_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeysig_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_eskeysig()) {
+    _this->_impl_.eskeysig_.Set(from._internal_eskeysig(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.buildhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buildhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_buildhash()) {
+    _this->_impl_.buildhash_.Set(from._internal_buildhash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.deviceprops_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deviceprops_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_deviceprops()) {
+    _this->_impl_.deviceprops_.Set(from._internal_deviceprops(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DevicePairingRegistrationData)
+}
+
+inline void ClientPayload_DevicePairingRegistrationData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.eregid_){}
+    , decltype(_impl_.ekeytype_){}
+    , decltype(_impl_.eident_){}
+    , decltype(_impl_.eskeyid_){}
+    , decltype(_impl_.eskeyval_){}
+    , decltype(_impl_.eskeysig_){}
+    , decltype(_impl_.buildhash_){}
+    , decltype(_impl_.deviceprops_){}
+  };
+  _impl_.eregid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eregid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.ekeytype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ekeytype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.eident_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eident_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.eskeyid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeyid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.eskeyval_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeyval_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.eskeysig_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.eskeysig_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.buildhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buildhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.deviceprops_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deviceprops_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPayload_DevicePairingRegistrationData::~ClientPayload_DevicePairingRegistrationData() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.DevicePairingRegistrationData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_DevicePairingRegistrationData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.eregid_.Destroy();
+  _impl_.ekeytype_.Destroy();
+  _impl_.eident_.Destroy();
+  _impl_.eskeyid_.Destroy();
+  _impl_.eskeyval_.Destroy();
+  _impl_.eskeysig_.Destroy();
+  _impl_.buildhash_.Destroy();
+  _impl_.deviceprops_.Destroy();
+}
+
+void ClientPayload_DevicePairingRegistrationData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_DevicePairingRegistrationData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DevicePairingRegistrationData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.eregid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.ekeytype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.eident_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.eskeyid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.eskeyval_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.eskeysig_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.buildhash_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.deviceprops_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_DevicePairingRegistrationData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes eRegid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_eregid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes eKeytype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_ekeytype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes eIdent = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_eident();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes eSkeyId = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_eskeyid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes eSkeyVal = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_eskeyval();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes eSkeySig = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_eskeysig();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes buildHash = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_buildhash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes deviceProps = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_deviceprops();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_DevicePairingRegistrationData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DevicePairingRegistrationData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes eRegid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_eregid(), target);
+  }
+
+  // optional bytes eKeytype = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_ekeytype(), target);
+  }
+
+  // optional bytes eIdent = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_eident(), target);
+  }
+
+  // optional bytes eSkeyId = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_eskeyid(), target);
+  }
+
+  // optional bytes eSkeyVal = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_eskeyval(), target);
+  }
+
+  // optional bytes eSkeySig = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_eskeysig(), target);
+  }
+
+  // optional bytes buildHash = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        7, this->_internal_buildhash(), target);
+  }
+
+  // optional bytes deviceProps = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_deviceprops(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.DevicePairingRegistrationData)
+  return target;
+}
+
+size_t ClientPayload_DevicePairingRegistrationData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DevicePairingRegistrationData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional bytes eRegid = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_eregid());
+    }
+
+    // optional bytes eKeytype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_ekeytype());
+    }
+
+    // optional bytes eIdent = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_eident());
+    }
+
+    // optional bytes eSkeyId = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_eskeyid());
+    }
+
+    // optional bytes eSkeyVal = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_eskeyval());
+    }
+
+    // optional bytes eSkeySig = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_eskeysig());
+    }
+
+    // optional bytes buildHash = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_buildhash());
+    }
+
+    // optional bytes deviceProps = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_deviceprops());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DevicePairingRegistrationData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_DevicePairingRegistrationData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DevicePairingRegistrationData::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_DevicePairingRegistrationData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_DevicePairingRegistrationData*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_DevicePairingRegistrationData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DevicePairingRegistrationData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_eregid(from._internal_eregid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_ekeytype(from._internal_ekeytype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_eident(from._internal_eident());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_eskeyid(from._internal_eskeyid());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_eskeyval(from._internal_eskeyval());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_eskeysig(from._internal_eskeysig());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_buildhash(from._internal_buildhash());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_deviceprops(from._internal_deviceprops());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_DevicePairingRegistrationData::CopyFrom(const ClientPayload_DevicePairingRegistrationData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DevicePairingRegistrationData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_DevicePairingRegistrationData::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_DevicePairingRegistrationData::InternalSwap(ClientPayload_DevicePairingRegistrationData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.eregid_, lhs_arena,
+      &other->_impl_.eregid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ekeytype_, lhs_arena,
+      &other->_impl_.ekeytype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.eident_, lhs_arena,
+      &other->_impl_.eident_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.eskeyid_, lhs_arena,
+      &other->_impl_.eskeyid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.eskeyval_, lhs_arena,
+      &other->_impl_.eskeyval_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.eskeysig_, lhs_arena,
+      &other->_impl_.eskeysig_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.buildhash_, lhs_arena,
+      &other->_impl_.buildhash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.deviceprops_, lhs_arena,
+      &other->_impl_.deviceprops_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DevicePairingRegistrationData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[16]);
+}
+
+// ===================================================================
+
+class ClientPayload_UserAgent_AppVersion::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_UserAgent_AppVersion>()._impl_._has_bits_);
+  static void set_has_primary(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_secondary(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_tertiary(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_quaternary(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_quinary(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent.AppVersion)
+}
+ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_UserAgent_AppVersion* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.primary_){}
+    , decltype(_impl_.secondary_){}
+    , decltype(_impl_.tertiary_){}
+    , decltype(_impl_.quaternary_){}
+    , decltype(_impl_.quinary_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.primary_, &from._impl_.primary_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.quinary_) -
+    reinterpret_cast<char*>(&_impl_.primary_)) + sizeof(_impl_.quinary_));
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent.AppVersion)
+}
+
+inline void ClientPayload_UserAgent_AppVersion::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.primary_){0u}
+    , decltype(_impl_.secondary_){0u}
+    , decltype(_impl_.tertiary_){0u}
+    , decltype(_impl_.quaternary_){0u}
+    , decltype(_impl_.quinary_){0u}
+  };
+}
+
+ClientPayload_UserAgent_AppVersion::~ClientPayload_UserAgent_AppVersion() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent.AppVersion)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_UserAgent_AppVersion::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ClientPayload_UserAgent_AppVersion::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_UserAgent_AppVersion::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent.AppVersion)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    ::memset(&_impl_.primary_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.quinary_) -
+        reinterpret_cast<char*>(&_impl_.primary_)) + sizeof(_impl_.quinary_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_UserAgent_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 primary = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_primary(&has_bits);
+          _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 secondary = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_secondary(&has_bits);
+          _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 tertiary = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_tertiary(&has_bits);
+          _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 quaternary = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_quaternary(&has_bits);
+          _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 quinary = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_quinary(&has_bits);
+          _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_UserAgent_AppVersion::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent.AppVersion)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 primary = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target);
+  }
+
+  // optional uint32 secondary = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target);
+  }
+
+  // optional uint32 tertiary = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target);
+  }
+
+  // optional uint32 quaternary = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target);
+  }
+
+  // optional uint32 quinary = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.UserAgent.AppVersion)
+  return target;
+}
+
+size_t ClientPayload_UserAgent_AppVersion::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent.AppVersion)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional uint32 primary = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary());
+    }
+
+    // optional uint32 secondary = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary());
+    }
+
+    // optional uint32 tertiary = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary());
+    }
+
+    // optional uint32 quaternary = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary());
+    }
+
+    // optional uint32 quinary = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent_AppVersion::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_UserAgent_AppVersion::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent_AppVersion::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_UserAgent_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_UserAgent_AppVersion*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_UserAgent_AppVersion&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent.AppVersion)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.primary_ = from._impl_.primary_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.secondary_ = from._impl_.secondary_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.tertiary_ = from._impl_.tertiary_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.quaternary_ = from._impl_.quaternary_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.quinary_ = from._impl_.quinary_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_UserAgent_AppVersion::CopyFrom(const ClientPayload_UserAgent_AppVersion& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent.AppVersion)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_UserAgent_AppVersion::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_UserAgent_AppVersion::InternalSwap(ClientPayload_UserAgent_AppVersion* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.quinary_)
+      + sizeof(ClientPayload_UserAgent_AppVersion::_impl_.quinary_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.primary_)>(
+          reinterpret_cast<char*>(&_impl_.primary_),
+          reinterpret_cast<char*>(&other->_impl_.primary_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent_AppVersion::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[17]);
+}
+
+// ===================================================================
+
+class ClientPayload_UserAgent::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_UserAgent>()._impl_._has_bits_);
+  static void set_has_platform(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::ClientPayload_UserAgent_AppVersion& appversion(const ClientPayload_UserAgent* msg);
+  static void set_has_appversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_mcc(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mnc(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_osversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_manufacturer(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_device(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_osbuildnumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_phoneid(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_releasechannel(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_localelanguageiso6391(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_localecountryiso31661alpha2(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_deviceboard(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+const ::proto::ClientPayload_UserAgent_AppVersion&
+ClientPayload_UserAgent::_Internal::appversion(const ClientPayload_UserAgent* msg) {
+  return *msg->_impl_.appversion_;
+}
+ClientPayload_UserAgent::ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent)
+}
+ClientPayload_UserAgent::ClientPayload_UserAgent(const ClientPayload_UserAgent& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_UserAgent* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mcc_){}
+    , decltype(_impl_.mnc_){}
+    , decltype(_impl_.osversion_){}
+    , decltype(_impl_.manufacturer_){}
+    , decltype(_impl_.device_){}
+    , decltype(_impl_.osbuildnumber_){}
+    , decltype(_impl_.phoneid_){}
+    , decltype(_impl_.localelanguageiso6391_){}
+    , decltype(_impl_.localecountryiso31661alpha2_){}
+    , decltype(_impl_.deviceboard_){}
+    , decltype(_impl_.appversion_){nullptr}
+    , decltype(_impl_.platform_){}
+    , decltype(_impl_.releasechannel_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.mcc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mcc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mcc()) {
+    _this->_impl_.mcc_.Set(from._internal_mcc(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mnc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mnc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mnc()) {
+    _this->_impl_.mnc_.Set(from._internal_mnc(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.osversion_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.osversion_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_osversion()) {
+    _this->_impl_.osversion_.Set(from._internal_osversion(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.manufacturer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.manufacturer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_manufacturer()) {
+    _this->_impl_.manufacturer_.Set(from._internal_manufacturer(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.device_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.device_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_device()) {
+    _this->_impl_.device_.Set(from._internal_device(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.osbuildnumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_osbuildnumber()) {
+    _this->_impl_.osbuildnumber_.Set(from._internal_osbuildnumber(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.phoneid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phoneid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_phoneid()) {
+    _this->_impl_.phoneid_.Set(from._internal_phoneid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localelanguageiso6391_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localelanguageiso6391()) {
+    _this->_impl_.localelanguageiso6391_.Set(from._internal_localelanguageiso6391(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localecountryiso31661alpha2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localecountryiso31661alpha2()) {
+    _this->_impl_.localecountryiso31661alpha2_.Set(from._internal_localecountryiso31661alpha2(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.deviceboard_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deviceboard_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_deviceboard()) {
+    _this->_impl_.deviceboard_.Set(from._internal_deviceboard(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_appversion()) {
+    _this->_impl_.appversion_ = new ::proto::ClientPayload_UserAgent_AppVersion(*from._impl_.appversion_);
+  }
+  ::memcpy(&_impl_.platform_, &from._impl_.platform_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.releasechannel_) -
+    reinterpret_cast<char*>(&_impl_.platform_)) + sizeof(_impl_.releasechannel_));
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent)
+}
+
+inline void ClientPayload_UserAgent::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mcc_){}
+    , decltype(_impl_.mnc_){}
+    , decltype(_impl_.osversion_){}
+    , decltype(_impl_.manufacturer_){}
+    , decltype(_impl_.device_){}
+    , decltype(_impl_.osbuildnumber_){}
+    , decltype(_impl_.phoneid_){}
+    , decltype(_impl_.localelanguageiso6391_){}
+    , decltype(_impl_.localecountryiso31661alpha2_){}
+    , decltype(_impl_.deviceboard_){}
+    , decltype(_impl_.appversion_){nullptr}
+    , decltype(_impl_.platform_){0}
+    , decltype(_impl_.releasechannel_){0}
+  };
+  _impl_.mcc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mcc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mnc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mnc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.osversion_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.osversion_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.manufacturer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.manufacturer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.device_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.device_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.osbuildnumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.phoneid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phoneid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localelanguageiso6391_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localecountryiso31661alpha2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.deviceboard_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deviceboard_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPayload_UserAgent::~ClientPayload_UserAgent() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_UserAgent::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mcc_.Destroy();
+  _impl_.mnc_.Destroy();
+  _impl_.osversion_.Destroy();
+  _impl_.manufacturer_.Destroy();
+  _impl_.device_.Destroy();
+  _impl_.osbuildnumber_.Destroy();
+  _impl_.phoneid_.Destroy();
+  _impl_.localelanguageiso6391_.Destroy();
+  _impl_.localecountryiso31661alpha2_.Destroy();
+  _impl_.deviceboard_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.appversion_;
+}
+
+void ClientPayload_UserAgent::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_UserAgent::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.mcc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mnc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.osversion_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.manufacturer_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.device_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.osbuildnumber_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.phoneid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.localelanguageiso6391_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000700u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.localecountryiso31661alpha2_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.deviceboard_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.appversion_ != nullptr);
+      _impl_.appversion_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00001800u) {
+    ::memset(&_impl_.platform_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.releasechannel_) -
+        reinterpret_cast<char*>(&_impl_.platform_)) + sizeof(_impl_.releasechannel_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_UserAgent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.ClientPayload.UserAgent.Platform platform = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_Platform_IsValid(val))) {
+            _internal_set_platform(static_cast<::proto::ClientPayload_UserAgent_Platform>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_appversion(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mcc = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_mcc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mcc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mnc = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_mnc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mnc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string osVersion = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_osversion();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osVersion");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string manufacturer = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_manufacturer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.manufacturer");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string device = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_device();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.device");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string osBuildNumber = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_osbuildnumber();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osBuildNumber");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string phoneId = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_phoneid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.phoneId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(val))) {
+            _internal_set_releasechannel(static_cast<::proto::ClientPayload_UserAgent_ReleaseChannel>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string localeLanguageIso6391 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_localelanguageiso6391();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeLanguageIso6391");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string localeCountryIso31661Alpha2 = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          auto str = _internal_mutable_localecountryiso31661alpha2();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string deviceBoard = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_deviceboard();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.deviceBoard");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_UserAgent::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.ClientPayload.UserAgent.Platform platform = 1;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_platform(), target);
+  }
+
+  // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::appversion(this),
+        _Internal::appversion(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string mcc = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mcc().data(), static_cast<int>(this->_internal_mcc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.mcc");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_mcc(), target);
+  }
+
+  // optional string mnc = 4;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mnc().data(), static_cast<int>(this->_internal_mnc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.mnc");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_mnc(), target);
+  }
+
+  // optional string osVersion = 5;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_osversion().data(), static_cast<int>(this->_internal_osversion().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.osVersion");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_osversion(), target);
+  }
+
+  // optional string manufacturer = 6;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_manufacturer().data(), static_cast<int>(this->_internal_manufacturer().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.manufacturer");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_manufacturer(), target);
+  }
+
+  // optional string device = 7;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_device().data(), static_cast<int>(this->_internal_device().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.device");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_device(), target);
+  }
+
+  // optional string osBuildNumber = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_osbuildnumber().data(), static_cast<int>(this->_internal_osbuildnumber().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.osBuildNumber");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_osbuildnumber(), target);
+  }
+
+  // optional string phoneId = 9;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_phoneid().data(), static_cast<int>(this->_internal_phoneid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.phoneId");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_phoneid(), target);
+  }
+
+  // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_releasechannel(), target);
+  }
+
+  // optional string localeLanguageIso6391 = 11;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_localelanguageiso6391().data(), static_cast<int>(this->_internal_localelanguageiso6391().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.localeLanguageIso6391");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_localelanguageiso6391(), target);
+  }
+
+  // optional string localeCountryIso31661Alpha2 = 12;
+  if (cached_has_bits & 0x00000100u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_localecountryiso31661alpha2().data(), static_cast<int>(this->_internal_localecountryiso31661alpha2().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2");
+    target = stream->WriteStringMaybeAliased(
+        12, this->_internal_localecountryiso31661alpha2(), target);
+  }
+
+  // optional string deviceBoard = 13;
+  if (cached_has_bits & 0x00000200u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_deviceboard().data(), static_cast<int>(this->_internal_deviceboard().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.UserAgent.deviceBoard");
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_deviceboard(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.UserAgent)
+  return target;
+}
+
+size_t ClientPayload_UserAgent::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string mcc = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mcc());
+    }
+
+    // optional string mnc = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mnc());
+    }
+
+    // optional string osVersion = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_osversion());
+    }
+
+    // optional string manufacturer = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_manufacturer());
+    }
+
+    // optional string device = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_device());
+    }
+
+    // optional string osBuildNumber = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_osbuildnumber());
+    }
+
+    // optional string phoneId = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_phoneid());
+    }
+
+    // optional string localeLanguageIso6391 = 11;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_localelanguageiso6391());
+    }
+
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    // optional string localeCountryIso31661Alpha2 = 12;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_localecountryiso31661alpha2());
+    }
+
+    // optional string deviceBoard = 13;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_deviceboard());
+    }
+
+    // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.appversion_);
+    }
+
+    // optional .proto.ClientPayload.UserAgent.Platform platform = 1;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_platform());
+    }
+
+    // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_releasechannel());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_UserAgent::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_UserAgent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_UserAgent*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_UserAgent&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_mcc(from._internal_mcc());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mnc(from._internal_mnc());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_osversion(from._internal_osversion());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_manufacturer(from._internal_manufacturer());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_device(from._internal_device());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_osbuildnumber(from._internal_osbuildnumber());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_phoneid(from._internal_phoneid());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_localelanguageiso6391(from._internal_localelanguageiso6391());
+    }
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_localecountryiso31661alpha2(from._internal_localecountryiso31661alpha2());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_deviceboard(from._internal_deviceboard());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_appversion()->::proto::ClientPayload_UserAgent_AppVersion::MergeFrom(
+          from._internal_appversion());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.platform_ = from._impl_.platform_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.releasechannel_ = from._impl_.releasechannel_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_UserAgent::CopyFrom(const ClientPayload_UserAgent& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_UserAgent::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_UserAgent::InternalSwap(ClientPayload_UserAgent* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mcc_, lhs_arena,
+      &other->_impl_.mcc_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mnc_, lhs_arena,
+      &other->_impl_.mnc_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.osversion_, lhs_arena,
+      &other->_impl_.osversion_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.manufacturer_, lhs_arena,
+      &other->_impl_.manufacturer_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.device_, lhs_arena,
+      &other->_impl_.device_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.osbuildnumber_, lhs_arena,
+      &other->_impl_.osbuildnumber_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.phoneid_, lhs_arena,
+      &other->_impl_.phoneid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localelanguageiso6391_, lhs_arena,
+      &other->_impl_.localelanguageiso6391_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localecountryiso31661alpha2_, lhs_arena,
+      &other->_impl_.localecountryiso31661alpha2_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.deviceboard_, lhs_arena,
+      &other->_impl_.deviceboard_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.releasechannel_)
+      + sizeof(ClientPayload_UserAgent::_impl_.releasechannel_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.appversion_)>(
+          reinterpret_cast<char*>(&_impl_.appversion_),
+          reinterpret_cast<char*>(&other->_impl_.appversion_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[18]);
+}
+
+// ===================================================================
+
+class ClientPayload_WebInfo_WebdPayload::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_WebInfo_WebdPayload>()._impl_._has_bits_);
+  static void set_has_usesparticipantinkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_supportsstarredmessages(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_supportsdocumentmessages(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_supportsurlmessages(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_supportsmediaretry(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_supportse2eimage(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_supportse2evideo(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_supportse2eaudio(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_supportse2edocument(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_documenttypes(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_features(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo.WebdPayload)
+}
+ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_WebInfo_WebdPayload* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.documenttypes_){}
+    , decltype(_impl_.features_){}
+    , decltype(_impl_.usesparticipantinkey_){}
+    , decltype(_impl_.supportsstarredmessages_){}
+    , decltype(_impl_.supportsdocumentmessages_){}
+    , decltype(_impl_.supportsurlmessages_){}
+    , decltype(_impl_.supportsmediaretry_){}
+    , decltype(_impl_.supportse2eimage_){}
+    , decltype(_impl_.supportse2evideo_){}
+    , decltype(_impl_.supportse2eaudio_){}
+    , decltype(_impl_.supportse2edocument_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.documenttypes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.documenttypes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_documenttypes()) {
+    _this->_impl_.documenttypes_.Set(from._internal_documenttypes(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.features_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.features_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_features()) {
+    _this->_impl_.features_.Set(from._internal_features(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.usesparticipantinkey_, &from._impl_.usesparticipantinkey_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.supportse2edocument_) -
+    reinterpret_cast<char*>(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2edocument_));
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo.WebdPayload)
+}
+
+inline void ClientPayload_WebInfo_WebdPayload::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.documenttypes_){}
+    , decltype(_impl_.features_){}
+    , decltype(_impl_.usesparticipantinkey_){false}
+    , decltype(_impl_.supportsstarredmessages_){false}
+    , decltype(_impl_.supportsdocumentmessages_){false}
+    , decltype(_impl_.supportsurlmessages_){false}
+    , decltype(_impl_.supportsmediaretry_){false}
+    , decltype(_impl_.supportse2eimage_){false}
+    , decltype(_impl_.supportse2evideo_){false}
+    , decltype(_impl_.supportse2eaudio_){false}
+    , decltype(_impl_.supportse2edocument_){false}
+  };
+  _impl_.documenttypes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.documenttypes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.features_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.features_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPayload_WebInfo_WebdPayload::~ClientPayload_WebInfo_WebdPayload() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo.WebdPayload)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_WebInfo_WebdPayload::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.documenttypes_.Destroy();
+  _impl_.features_.Destroy();
+}
+
+void ClientPayload_WebInfo_WebdPayload::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_WebInfo_WebdPayload::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo.WebdPayload)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.documenttypes_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.features_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x000000fcu) {
+    ::memset(&_impl_.usesparticipantinkey_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.supportse2eimage_) -
+        reinterpret_cast<char*>(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2eimage_));
+  }
+  if (cached_has_bits & 0x00000700u) {
+    ::memset(&_impl_.supportse2evideo_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.supportse2edocument_) -
+        reinterpret_cast<char*>(&_impl_.supportse2evideo_)) + sizeof(_impl_.supportse2edocument_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_WebInfo_WebdPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool usesParticipantInKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_usesparticipantinkey(&has_bits);
+          _impl_.usesparticipantinkey_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsStarredMessages = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_supportsstarredmessages(&has_bits);
+          _impl_.supportsstarredmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsDocumentMessages = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_supportsdocumentmessages(&has_bits);
+          _impl_.supportsdocumentmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsUrlMessages = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_supportsurlmessages(&has_bits);
+          _impl_.supportsurlmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsMediaRetry = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_supportsmediaretry(&has_bits);
+          _impl_.supportsmediaretry_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsE2EImage = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_supportse2eimage(&has_bits);
+          _impl_.supportse2eimage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsE2EVideo = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_supportse2evideo(&has_bits);
+          _impl_.supportse2evideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsE2EAudio = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_supportse2eaudio(&has_bits);
+          _impl_.supportse2eaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool supportsE2EDocument = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_supportse2edocument(&has_bits);
+          _impl_.supportse2edocument_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string documentTypes = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          auto str = _internal_mutable_documenttypes();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.WebdPayload.documentTypes");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes features = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_features();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_WebInfo_WebdPayload::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo.WebdPayload)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool usesParticipantInKey = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_usesparticipantinkey(), target);
+  }
+
+  // optional bool supportsStarredMessages = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_supportsstarredmessages(), target);
+  }
+
+  // optional bool supportsDocumentMessages = 3;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_supportsdocumentmessages(), target);
+  }
+
+  // optional bool supportsUrlMessages = 4;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_supportsurlmessages(), target);
+  }
+
+  // optional bool supportsMediaRetry = 5;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_supportsmediaretry(), target);
+  }
+
+  // optional bool supportsE2EImage = 6;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_supportse2eimage(), target);
+  }
+
+  // optional bool supportsE2EVideo = 7;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_supportse2evideo(), target);
+  }
+
+  // optional bool supportsE2EAudio = 8;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_supportse2eaudio(), target);
+  }
+
+  // optional bool supportsE2EDocument = 9;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_supportse2edocument(), target);
+  }
+
+  // optional string documentTypes = 10;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_documenttypes().data(), static_cast<int>(this->_internal_documenttypes().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.WebInfo.WebdPayload.documentTypes");
+    target = stream->WriteStringMaybeAliased(
+        10, this->_internal_documenttypes(), target);
+  }
+
+  // optional bytes features = 11;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        11, this->_internal_features(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.WebInfo.WebdPayload)
+  return target;
+}
+
+size_t ClientPayload_WebInfo_WebdPayload::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo.WebdPayload)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string documentTypes = 10;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_documenttypes());
+    }
+
+    // optional bytes features = 11;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_features());
+    }
+
+    // optional bool usesParticipantInKey = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsStarredMessages = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsDocumentMessages = 3;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsUrlMessages = 4;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsMediaRetry = 5;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsE2EImage = 6;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0x00000700u) {
+    // optional bool supportsE2EVideo = 7;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsE2EAudio = 8;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool supportsE2EDocument = 9;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo_WebdPayload::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_WebInfo_WebdPayload::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo_WebdPayload::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_WebInfo_WebdPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_WebInfo_WebdPayload*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_WebInfo_WebdPayload&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo.WebdPayload)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_documenttypes(from._internal_documenttypes());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_features(from._internal_features());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.usesparticipantinkey_ = from._impl_.usesparticipantinkey_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.supportsstarredmessages_ = from._impl_.supportsstarredmessages_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.supportsdocumentmessages_ = from._impl_.supportsdocumentmessages_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.supportsurlmessages_ = from._impl_.supportsurlmessages_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.supportsmediaretry_ = from._impl_.supportsmediaretry_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.supportse2eimage_ = from._impl_.supportse2eimage_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000700u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.supportse2evideo_ = from._impl_.supportse2evideo_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.supportse2eaudio_ = from._impl_.supportse2eaudio_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.supportse2edocument_ = from._impl_.supportse2edocument_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_WebInfo_WebdPayload::CopyFrom(const ClientPayload_WebInfo_WebdPayload& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo.WebdPayload)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_WebInfo_WebdPayload::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_WebInfo_WebdPayload::InternalSwap(ClientPayload_WebInfo_WebdPayload* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.documenttypes_, lhs_arena,
+      &other->_impl_.documenttypes_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.features_, lhs_arena,
+      &other->_impl_.features_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_)
+      + sizeof(ClientPayload_WebInfo_WebdPayload::_impl_.supportse2edocument_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_)>(
+          reinterpret_cast<char*>(&_impl_.usesparticipantinkey_),
+          reinterpret_cast<char*>(&other->_impl_.usesparticipantinkey_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo_WebdPayload::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[19]);
+}
+
+// ===================================================================
+
+class ClientPayload_WebInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload_WebInfo>()._impl_._has_bits_);
+  static void set_has_reftoken(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload(const ClientPayload_WebInfo* msg);
+  static void set_has_webdpayload(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_websubplatform(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::ClientPayload_WebInfo_WebdPayload&
+ClientPayload_WebInfo::_Internal::webdpayload(const ClientPayload_WebInfo* msg) {
+  return *msg->_impl_.webdpayload_;
+}
+ClientPayload_WebInfo::ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo)
+}
+ClientPayload_WebInfo::ClientPayload_WebInfo(const ClientPayload_WebInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload_WebInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.reftoken_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.webdpayload_){nullptr}
+    , decltype(_impl_.websubplatform_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.reftoken_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.reftoken_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_reftoken()) {
+    _this->_impl_.reftoken_.Set(from._internal_reftoken(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_webdpayload()) {
+    _this->_impl_.webdpayload_ = new ::proto::ClientPayload_WebInfo_WebdPayload(*from._impl_.webdpayload_);
+  }
+  _this->_impl_.websubplatform_ = from._impl_.websubplatform_;
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo)
+}
+
+inline void ClientPayload_WebInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.reftoken_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.webdpayload_){nullptr}
+    , decltype(_impl_.websubplatform_){0}
+  };
+  _impl_.reftoken_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.reftoken_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPayload_WebInfo::~ClientPayload_WebInfo() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload_WebInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.reftoken_.Destroy();
+  _impl_.version_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.webdpayload_;
+}
+
+void ClientPayload_WebInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload_WebInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.reftoken_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.version_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.webdpayload_ != nullptr);
+      _impl_.webdpayload_->Clear();
+    }
+  }
+  _impl_.websubplatform_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload_WebInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string refToken = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_reftoken();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.refToken");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.version");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_webdpayload(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(val))) {
+            _internal_set_websubplatform(static_cast<::proto::ClientPayload_WebInfo_WebSubPlatform>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload_WebInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string refToken = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_reftoken().data(), static_cast<int>(this->_internal_reftoken().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.WebInfo.refToken");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_reftoken(), target);
+  }
+
+  // optional string version = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.WebInfo.version");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_version(), target);
+  }
+
+  // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::webdpayload(this),
+        _Internal::webdpayload(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_websubplatform(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload.WebInfo)
+  return target;
+}
+
+size_t ClientPayload_WebInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string refToken = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_reftoken());
+    }
+
+    // optional string version = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_version());
+    }
+
+    // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.webdpayload_);
+    }
+
+    // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_websubplatform());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload_WebInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload_WebInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload_WebInfo*>(&to_msg);
+  auto& from = static_cast<const ClientPayload_WebInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_reftoken(from._internal_reftoken());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_version(from._internal_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_webdpayload()->::proto::ClientPayload_WebInfo_WebdPayload::MergeFrom(
+          from._internal_webdpayload());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.websubplatform_ = from._impl_.websubplatform_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload_WebInfo::CopyFrom(const ClientPayload_WebInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload_WebInfo::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload_WebInfo::InternalSwap(ClientPayload_WebInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.reftoken_, lhs_arena,
+      &other->_impl_.reftoken_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.websubplatform_)
+      + sizeof(ClientPayload_WebInfo::_impl_.websubplatform_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.webdpayload_)>(
+          reinterpret_cast<char*>(&_impl_.webdpayload_),
+          reinterpret_cast<char*>(&other->_impl_.webdpayload_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[20]);
+}
+
+// ===================================================================
+
+class ClientPayload::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPayload>()._impl_._has_bits_);
+  static void set_has_username(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_passive(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static const ::proto::ClientPayload_UserAgent& useragent(const ClientPayload* msg);
+  static void set_has_useragent(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::ClientPayload_WebInfo& webinfo(const ClientPayload* msg);
+  static void set_has_webinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_pushname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_sessionid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_shortconnect(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_connecttype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_connectreason(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static const ::proto::ClientPayload_DNSSource& dnssource(const ClientPayload* msg);
+  static void set_has_dnssource(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_connectattemptcount(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_device(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata(const ClientPayload* msg);
+  static void set_has_devicepairingdata(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_product(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_fbcat(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fbuseragent(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_oc(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_lc(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_iosappextension(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static void set_has_fbappid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_fbdeviceid(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_pull(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_paddingbytes(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+const ::proto::ClientPayload_UserAgent&
+ClientPayload::_Internal::useragent(const ClientPayload* msg) {
+  return *msg->_impl_.useragent_;
+}
+const ::proto::ClientPayload_WebInfo&
+ClientPayload::_Internal::webinfo(const ClientPayload* msg) {
+  return *msg->_impl_.webinfo_;
+}
+const ::proto::ClientPayload_DNSSource&
+ClientPayload::_Internal::dnssource(const ClientPayload* msg) {
+  return *msg->_impl_.dnssource_;
+}
+const ::proto::ClientPayload_DevicePairingRegistrationData&
+ClientPayload::_Internal::devicepairingdata(const ClientPayload* msg) {
+  return *msg->_impl_.devicepairingdata_;
+}
+ClientPayload::ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ClientPayload)
+}
+ClientPayload::ClientPayload(const ClientPayload& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ClientPayload* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.shards_){from._impl_.shards_}
+    , decltype(_impl_.pushname_){}
+    , decltype(_impl_.fbcat_){}
+    , decltype(_impl_.fbuseragent_){}
+    , decltype(_impl_.fbdeviceid_){}
+    , decltype(_impl_.paddingbytes_){}
+    , decltype(_impl_.useragent_){nullptr}
+    , decltype(_impl_.webinfo_){nullptr}
+    , decltype(_impl_.dnssource_){nullptr}
+    , decltype(_impl_.devicepairingdata_){nullptr}
+    , decltype(_impl_.username_){}
+    , decltype(_impl_.sessionid_){}
+    , decltype(_impl_.connecttype_){}
+    , decltype(_impl_.connectreason_){}
+    , decltype(_impl_.connectattemptcount_){}
+    , decltype(_impl_.passive_){}
+    , decltype(_impl_.shortconnect_){}
+    , decltype(_impl_.oc_){}
+    , decltype(_impl_.pull_){}
+    , decltype(_impl_.device_){}
+    , decltype(_impl_.product_){}
+    , decltype(_impl_.lc_){}
+    , decltype(_impl_.fbappid_){}
+    , decltype(_impl_.iosappextension_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pushname()) {
+    _this->_impl_.pushname_.Set(from._internal_pushname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fbcat_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbcat_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fbcat()) {
+    _this->_impl_.fbcat_.Set(from._internal_fbcat(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fbuseragent_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fbuseragent()) {
+    _this->_impl_.fbuseragent_.Set(from._internal_fbuseragent(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fbdeviceid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fbdeviceid()) {
+    _this->_impl_.fbdeviceid_.Set(from._internal_fbdeviceid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.paddingbytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_paddingbytes()) {
+    _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_useragent()) {
+    _this->_impl_.useragent_ = new ::proto::ClientPayload_UserAgent(*from._impl_.useragent_);
+  }
+  if (from._internal_has_webinfo()) {
+    _this->_impl_.webinfo_ = new ::proto::ClientPayload_WebInfo(*from._impl_.webinfo_);
+  }
+  if (from._internal_has_dnssource()) {
+    _this->_impl_.dnssource_ = new ::proto::ClientPayload_DNSSource(*from._impl_.dnssource_);
+  }
+  if (from._internal_has_devicepairingdata()) {
+    _this->_impl_.devicepairingdata_ = new ::proto::ClientPayload_DevicePairingRegistrationData(*from._impl_.devicepairingdata_);
+  }
+  ::memcpy(&_impl_.username_, &from._impl_.username_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.iosappextension_) -
+    reinterpret_cast<char*>(&_impl_.username_)) + sizeof(_impl_.iosappextension_));
+  // @@protoc_insertion_point(copy_constructor:proto.ClientPayload)
+}
+
+inline void ClientPayload::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.shards_){arena}
+    , decltype(_impl_.pushname_){}
+    , decltype(_impl_.fbcat_){}
+    , decltype(_impl_.fbuseragent_){}
+    , decltype(_impl_.fbdeviceid_){}
+    , decltype(_impl_.paddingbytes_){}
+    , decltype(_impl_.useragent_){nullptr}
+    , decltype(_impl_.webinfo_){nullptr}
+    , decltype(_impl_.dnssource_){nullptr}
+    , decltype(_impl_.devicepairingdata_){nullptr}
+    , decltype(_impl_.username_){uint64_t{0u}}
+    , decltype(_impl_.sessionid_){0}
+    , decltype(_impl_.connecttype_){0}
+    , decltype(_impl_.connectreason_){0}
+    , decltype(_impl_.connectattemptcount_){0u}
+    , decltype(_impl_.passive_){false}
+    , decltype(_impl_.shortconnect_){false}
+    , decltype(_impl_.oc_){false}
+    , decltype(_impl_.pull_){false}
+    , decltype(_impl_.device_){0u}
+    , decltype(_impl_.product_){0}
+    , decltype(_impl_.lc_){0}
+    , decltype(_impl_.fbappid_){uint64_t{0u}}
+    , decltype(_impl_.iosappextension_){0}
+  };
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fbcat_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbcat_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fbuseragent_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fbdeviceid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.paddingbytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPayload::~ClientPayload() {
+  // @@protoc_insertion_point(destructor:proto.ClientPayload)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPayload::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.shards_.~RepeatedField();
+  _impl_.pushname_.Destroy();
+  _impl_.fbcat_.Destroy();
+  _impl_.fbuseragent_.Destroy();
+  _impl_.fbdeviceid_.Destroy();
+  _impl_.paddingbytes_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.useragent_;
+  if (this != internal_default_instance()) delete _impl_.webinfo_;
+  if (this != internal_default_instance()) delete _impl_.dnssource_;
+  if (this != internal_default_instance()) delete _impl_.devicepairingdata_;
+}
+
+void ClientPayload::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPayload::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ClientPayload)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.shards_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.pushname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.fbcat_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fbuseragent_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.fbdeviceid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.paddingbytes_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.useragent_ != nullptr);
+      _impl_.useragent_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.webinfo_ != nullptr);
+      _impl_.webinfo_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.dnssource_ != nullptr);
+      _impl_.dnssource_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000100u) {
+    GOOGLE_DCHECK(_impl_.devicepairingdata_ != nullptr);
+    _impl_.devicepairingdata_->Clear();
+  }
+  if (cached_has_bits & 0x0000fe00u) {
+    ::memset(&_impl_.username_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.shortconnect_) -
+        reinterpret_cast<char*>(&_impl_.username_)) + sizeof(_impl_.shortconnect_));
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    ::memset(&_impl_.oc_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.iosappextension_) -
+        reinterpret_cast<char*>(&_impl_.oc_)) + sizeof(_impl_.iosappextension_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ClientPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 username = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_username(&has_bits);
+          _impl_.username_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool passive = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_passive(&has_bits);
+          _impl_.passive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.UserAgent userAgent = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_useragent(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.WebInfo webInfo = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_webinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pushName = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_pushname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ClientPayload.pushName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional sfixed32 sessionId = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 77)) {
+          _Internal::set_has_sessionid(&has_bits);
+          _impl_.sessionid_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<int32_t>(ptr);
+          ptr += sizeof(int32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool shortConnect = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_shortconnect(&has_bits);
+          _impl_.shortconnect_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.ConnectType connectType = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectType_IsValid(val))) {
+            _internal_set_connecttype(static_cast<::proto::ClientPayload_ConnectType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.ConnectReason connectReason = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectReason_IsValid(val))) {
+            _internal_set_connectreason(static_cast<::proto::ClientPayload_ConnectReason>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated int32 shards = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            _internal_add_shards(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<112>(ptr));
+        } else if (static_cast<uint8_t>(tag) == 114) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_shards(), ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.DNSSource dnsSource = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_dnssource(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 connectAttemptCount = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_connectattemptcount(&has_bits);
+          _impl_.connectattemptcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 device = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_device(&has_bits);
+          _impl_.device_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_devicepairingdata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.Product product = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_Product_IsValid(val))) {
+            _internal_set_product(static_cast<::proto::ClientPayload_Product>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fbCat = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_fbcat();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fbUserAgent = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          auto str = _internal_mutable_fbuseragent();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool oc = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
+          _Internal::set_has_oc(&has_bits);
+          _impl_.oc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 lc = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
+          _Internal::set_has_lc(&has_bits);
+          _impl_.lc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_IOSAppExtension_IsValid(val))) {
+            _internal_set_iosappextension(static_cast<::proto::ClientPayload_IOSAppExtension>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fbAppId = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _Internal::set_has_fbappid(&has_bits);
+          _impl_.fbappid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fbDeviceId = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          auto str = _internal_mutable_fbdeviceid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool pull = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_pull(&has_bits);
+          _impl_.pull_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes paddingBytes = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_paddingbytes();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPayload::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 username = 1;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_username(), target);
+  }
+
+  // optional bool passive = 3;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_passive(), target);
+  }
+
+  // optional .proto.ClientPayload.UserAgent userAgent = 5;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::useragent(this),
+        _Internal::useragent(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ClientPayload.WebInfo webInfo = 6;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::webinfo(this),
+        _Internal::webinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string pushName = 7;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pushname().data(), static_cast<int>(this->_internal_pushname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ClientPayload.pushName");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_pushname(), target);
+  }
+
+  // optional sfixed32 sessionId = 9;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(9, this->_internal_sessionid(), target);
+  }
+
+  // optional bool shortConnect = 10;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_shortconnect(), target);
+  }
+
+  // optional .proto.ClientPayload.ConnectType connectType = 12;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      12, this->_internal_connecttype(), target);
+  }
+
+  // optional .proto.ClientPayload.ConnectReason connectReason = 13;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      13, this->_internal_connectreason(), target);
+  }
+
+  // repeated int32 shards = 14;
+  for (int i = 0, n = this->_internal_shards_size(); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(14, this->_internal_shards(i), target);
+  }
+
+  // optional .proto.ClientPayload.DNSSource dnsSource = 15;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, _Internal::dnssource(this),
+        _Internal::dnssource(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 connectAttemptCount = 16;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_connectattemptcount(), target);
+  }
+
+  // optional uint32 device = 18;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_device(), target);
+  }
+
+  // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(19, _Internal::devicepairingdata(this),
+        _Internal::devicepairingdata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ClientPayload.Product product = 20;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      20, this->_internal_product(), target);
+  }
+
+  // optional bytes fbCat = 21;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        21, this->_internal_fbcat(), target);
+  }
+
+  // optional bytes fbUserAgent = 22;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        22, this->_internal_fbuseragent(), target);
+  }
+
+  // optional bool oc = 23;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_oc(), target);
+  }
+
+  // optional int32 lc = 24;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(24, this->_internal_lc(), target);
+  }
+
+  // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      30, this->_internal_iosappextension(), target);
+  }
+
+  // optional uint64 fbAppId = 31;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_fbappid(), target);
+  }
+
+  // optional bytes fbDeviceId = 32;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        32, this->_internal_fbdeviceid(), target);
+  }
+
+  // optional bool pull = 33;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(33, this->_internal_pull(), target);
+  }
+
+  // optional bytes paddingBytes = 34;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        34, this->_internal_paddingbytes(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ClientPayload)
+  return target;
+}
+
+size_t ClientPayload::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated int32 shards = 14;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      Int32Size(this->_impl_.shards_);
+    total_size += 1 *
+                  ::_pbi::FromIntSize(this->_internal_shards_size());
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string pushName = 7;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pushname());
+    }
+
+    // optional bytes fbCat = 21;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fbcat());
+    }
+
+    // optional bytes fbUserAgent = 22;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fbuseragent());
+    }
+
+    // optional bytes fbDeviceId = 32;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fbdeviceid());
+    }
+
+    // optional bytes paddingBytes = 34;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_paddingbytes());
+    }
+
+    // optional .proto.ClientPayload.UserAgent userAgent = 5;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.useragent_);
+    }
+
+    // optional .proto.ClientPayload.WebInfo webInfo = 6;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.webinfo_);
+    }
+
+    // optional .proto.ClientPayload.DNSSource dnsSource = 15;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.dnssource_);
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.devicepairingdata_);
+    }
+
+    // optional uint64 username = 1;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_username());
+    }
+
+    // optional sfixed32 sessionId = 9;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 4;
+    }
+
+    // optional .proto.ClientPayload.ConnectType connectType = 12;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_connecttype());
+    }
+
+    // optional .proto.ClientPayload.ConnectReason connectReason = 13;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_connectreason());
+    }
+
+    // optional uint32 connectAttemptCount = 16;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_connectattemptcount());
+    }
+
+    // optional bool passive = 3;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool shortConnect = 10;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    // optional bool oc = 23;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool pull = 33;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint32 device = 18;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_device());
+    }
+
+    // optional .proto.ClientPayload.Product product = 20;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_product());
+    }
+
+    // optional int32 lc = 24;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int32Size(
+          this->_internal_lc());
+    }
+
+    // optional uint64 fbAppId = 31;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_fbappid());
+    }
+
+    // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_iosappextension());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ClientPayload::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload::GetClassData() const { return &_class_data_; }
+
+
+void ClientPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ClientPayload*>(&to_msg);
+  auto& from = static_cast<const ClientPayload&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.shards_.MergeFrom(from._impl_.shards_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_pushname(from._internal_pushname());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_fbcat(from._internal_fbcat());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fbuseragent(from._internal_fbuseragent());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_fbdeviceid(from._internal_fbdeviceid());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_paddingbytes(from._internal_paddingbytes());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_useragent()->::proto::ClientPayload_UserAgent::MergeFrom(
+          from._internal_useragent());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_webinfo()->::proto::ClientPayload_WebInfo::MergeFrom(
+          from._internal_webinfo());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_dnssource()->::proto::ClientPayload_DNSSource::MergeFrom(
+          from._internal_dnssource());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_devicepairingdata()->::proto::ClientPayload_DevicePairingRegistrationData::MergeFrom(
+          from._internal_devicepairingdata());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.username_ = from._impl_.username_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.sessionid_ = from._impl_.sessionid_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.connecttype_ = from._impl_.connecttype_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.connectreason_ = from._impl_.connectreason_;
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.connectattemptcount_ = from._impl_.connectattemptcount_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.passive_ = from._impl_.passive_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.shortconnect_ = from._impl_.shortconnect_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.oc_ = from._impl_.oc_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.pull_ = from._impl_.pull_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.device_ = from._impl_.device_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.product_ = from._impl_.product_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.lc_ = from._impl_.lc_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.fbappid_ = from._impl_.fbappid_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.iosappextension_ = from._impl_.iosappextension_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ClientPayload::CopyFrom(const ClientPayload& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPayload::IsInitialized() const {
+  return true;
+}
+
+void ClientPayload::InternalSwap(ClientPayload* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.shards_.InternalSwap(&other->_impl_.shards_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pushname_, lhs_arena,
+      &other->_impl_.pushname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fbcat_, lhs_arena,
+      &other->_impl_.fbcat_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fbuseragent_, lhs_arena,
+      &other->_impl_.fbuseragent_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fbdeviceid_, lhs_arena,
+      &other->_impl_.fbdeviceid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.paddingbytes_, lhs_arena,
+      &other->_impl_.paddingbytes_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.iosappextension_)
+      + sizeof(ClientPayload::_impl_.iosappextension_)
+      - PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.useragent_)>(
+          reinterpret_cast<char*>(&_impl_.useragent_),
+          reinterpret_cast<char*>(&other->_impl_.useragent_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[21]);
+}
+
+// ===================================================================
+
+class ContextInfo_AdReplyInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ContextInfo_AdReplyInfo>()._impl_._has_bits_);
+  static void set_has_advertisername(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mediatype(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.AdReplyInfo)
+}
+ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ContextInfo_AdReplyInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.advertisername_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.mediatype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.advertisername_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.advertisername_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_advertisername()) {
+    _this->_impl_.advertisername_.Set(from._internal_advertisername(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.mediatype_ = from._impl_.mediatype_;
+  // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.AdReplyInfo)
+}
+
+inline void ContextInfo_AdReplyInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.advertisername_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.mediatype_){0}
+  };
+  _impl_.advertisername_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.advertisername_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ContextInfo_AdReplyInfo::~ContextInfo_AdReplyInfo() {
+  // @@protoc_insertion_point(destructor:proto.ContextInfo.AdReplyInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ContextInfo_AdReplyInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.advertisername_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.caption_.Destroy();
+}
+
+void ContextInfo_AdReplyInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ContextInfo_AdReplyInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.AdReplyInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.advertisername_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.mediatype_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ContextInfo_AdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string advertiserName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_advertisername();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.advertiserName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(val))) {
+            _internal_set_mediatype(static_cast<::proto::ContextInfo_AdReplyInfo_MediaType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ContextInfo_AdReplyInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.AdReplyInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string advertiserName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_advertisername().data(), static_cast<int>(this->_internal_advertisername().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.AdReplyInfo.advertiserName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_advertisername(), target);
+  }
+
+  // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_mediatype(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional string caption = 17;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.AdReplyInfo.caption");
+    target = stream->WriteStringMaybeAliased(
+        17, this->_internal_caption(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ContextInfo.AdReplyInfo)
+  return target;
+}
+
+size_t ContextInfo_AdReplyInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.AdReplyInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string advertiserName = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_advertisername());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional string caption = 17;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_AdReplyInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ContextInfo_AdReplyInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_AdReplyInfo::GetClassData() const { return &_class_data_; }
+
+
+void ContextInfo_AdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ContextInfo_AdReplyInfo*>(&to_msg);
+  auto& from = static_cast<const ContextInfo_AdReplyInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.AdReplyInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_advertisername(from._internal_advertisername());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.mediatype_ = from._impl_.mediatype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ContextInfo_AdReplyInfo::CopyFrom(const ContextInfo_AdReplyInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.AdReplyInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContextInfo_AdReplyInfo::IsInitialized() const {
+  return true;
+}
+
+void ContextInfo_AdReplyInfo::InternalSwap(ContextInfo_AdReplyInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.advertisername_, lhs_arena,
+      &other->_impl_.advertisername_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  swap(_impl_.mediatype_, other->_impl_.mediatype_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_AdReplyInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[22]);
+}
+
+// ===================================================================
+
+class ContextInfo_ExternalAdReplyInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ContextInfo_ExternalAdReplyInfo>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_mediatype(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_thumbnailurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_mediaurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_thumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_sourcetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_sourceid(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_sourceurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_containsautoreply(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_renderlargerthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_showadattribution(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+};
+
+ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.ExternalAdReplyInfo)
+}
+ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ContextInfo_ExternalAdReplyInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.thumbnailurl_){}
+    , decltype(_impl_.mediaurl_){}
+    , decltype(_impl_.thumbnail_){}
+    , decltype(_impl_.sourcetype_){}
+    , decltype(_impl_.sourceid_){}
+    , decltype(_impl_.sourceurl_){}
+    , decltype(_impl_.mediatype_){}
+    , decltype(_impl_.containsautoreply_){}
+    , decltype(_impl_.renderlargerthumbnail_){}
+    , decltype(_impl_.showadattribution_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailurl()) {
+    _this->_impl_.thumbnailurl_.Set(from._internal_thumbnailurl(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediaurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediaurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediaurl()) {
+    _this->_impl_.mediaurl_.Set(from._internal_mediaurl(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnail()) {
+    _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.sourcetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourcetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sourcetype()) {
+    _this->_impl_.sourcetype_.Set(from._internal_sourcetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.sourceid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourceid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sourceid()) {
+    _this->_impl_.sourceid_.Set(from._internal_sourceid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.sourceurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourceurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sourceurl()) {
+    _this->_impl_.sourceurl_.Set(from._internal_sourceurl(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.mediatype_, &from._impl_.mediatype_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.showadattribution_) -
+    reinterpret_cast<char*>(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_));
+  // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.ExternalAdReplyInfo)
+}
+
+inline void ContextInfo_ExternalAdReplyInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.thumbnailurl_){}
+    , decltype(_impl_.mediaurl_){}
+    , decltype(_impl_.thumbnail_){}
+    , decltype(_impl_.sourcetype_){}
+    , decltype(_impl_.sourceid_){}
+    , decltype(_impl_.sourceurl_){}
+    , decltype(_impl_.mediatype_){0}
+    , decltype(_impl_.containsautoreply_){false}
+    , decltype(_impl_.renderlargerthumbnail_){false}
+    , decltype(_impl_.showadattribution_){false}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediaurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediaurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.sourcetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourcetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.sourceid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourceid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.sourceurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sourceurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ContextInfo_ExternalAdReplyInfo::~ContextInfo_ExternalAdReplyInfo() {
+  // @@protoc_insertion_point(destructor:proto.ContextInfo.ExternalAdReplyInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ContextInfo_ExternalAdReplyInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.title_.Destroy();
+  _impl_.body_.Destroy();
+  _impl_.thumbnailurl_.Destroy();
+  _impl_.mediaurl_.Destroy();
+  _impl_.thumbnail_.Destroy();
+  _impl_.sourcetype_.Destroy();
+  _impl_.sourceid_.Destroy();
+  _impl_.sourceurl_.Destroy();
+}
+
+void ContextInfo_ExternalAdReplyInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ContextInfo_ExternalAdReplyInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.ExternalAdReplyInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.body_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.thumbnailurl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mediaurl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.thumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.sourcetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.sourceid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.sourceurl_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    ::memset(&_impl_.mediatype_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.showadattribution_) -
+        reinterpret_cast<char*>(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ContextInfo_ExternalAdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string body = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.body");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(val))) {
+            _internal_set_mediatype(static_cast<::proto::ContextInfo_ExternalAdReplyInfo_MediaType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string thumbnailUrl = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_thumbnailurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mediaUrl = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_mediaurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnail = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_thumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string sourceType = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_sourcetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceType");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string sourceId = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_sourceid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string sourceUrl = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_sourceurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool containsAutoReply = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_containsautoreply(&has_bits);
+          _impl_.containsautoreply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool renderLargerThumbnail = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_renderlargerthumbnail(&has_bits);
+          _impl_.renderlargerthumbnail_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool showAdAttribution = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_showadattribution(&has_bits);
+          _impl_.showadattribution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ContextInfo_ExternalAdReplyInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.ExternalAdReplyInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // optional string body = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_body().data(), static_cast<int>(this->_internal_body().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.body");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_body(), target);
+  }
+
+  // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_mediatype(), target);
+  }
+
+  // optional string thumbnailUrl = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_thumbnailurl().data(), static_cast<int>(this->_internal_thumbnailurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_thumbnailurl(), target);
+  }
+
+  // optional string mediaUrl = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mediaurl().data(), static_cast<int>(this->_internal_mediaurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_mediaurl(), target);
+  }
+
+  // optional bytes thumbnail = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_thumbnail(), target);
+  }
+
+  // optional string sourceType = 7;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_sourcetype().data(), static_cast<int>(this->_internal_sourcetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.sourceType");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_sourcetype(), target);
+  }
+
+  // optional string sourceId = 8;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_sourceid().data(), static_cast<int>(this->_internal_sourceid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.sourceId");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_sourceid(), target);
+  }
+
+  // optional string sourceUrl = 9;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_sourceurl().data(), static_cast<int>(this->_internal_sourceurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_sourceurl(), target);
+  }
+
+  // optional bool containsAutoReply = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_containsautoreply(), target);
+  }
+
+  // optional bool renderLargerThumbnail = 11;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_renderlargerthumbnail(), target);
+  }
+
+  // optional bool showAdAttribution = 12;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_showadattribution(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ContextInfo.ExternalAdReplyInfo)
+  return target;
+}
+
+size_t ContextInfo_ExternalAdReplyInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.ExternalAdReplyInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string title = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string body = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_body());
+    }
+
+    // optional string thumbnailUrl = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_thumbnailurl());
+    }
+
+    // optional string mediaUrl = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mediaurl());
+    }
+
+    // optional bytes thumbnail = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnail());
+    }
+
+    // optional string sourceType = 7;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_sourcetype());
+    }
+
+    // optional string sourceId = 8;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_sourceid());
+    }
+
+    // optional string sourceUrl = 9;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_sourceurl());
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype());
+    }
+
+    // optional bool containsAutoReply = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool renderLargerThumbnail = 11;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool showAdAttribution = 12;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_ExternalAdReplyInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ContextInfo_ExternalAdReplyInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_ExternalAdReplyInfo::GetClassData() const { return &_class_data_; }
+
+
+void ContextInfo_ExternalAdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ContextInfo_ExternalAdReplyInfo*>(&to_msg);
+  auto& from = static_cast<const ContextInfo_ExternalAdReplyInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.ExternalAdReplyInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_body(from._internal_body());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_thumbnailurl(from._internal_thumbnailurl());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mediaurl(from._internal_mediaurl());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_thumbnail(from._internal_thumbnail());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_sourcetype(from._internal_sourcetype());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_sourceid(from._internal_sourceid());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_sourceurl(from._internal_sourceurl());
+    }
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.mediatype_ = from._impl_.mediatype_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.containsautoreply_ = from._impl_.containsautoreply_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.renderlargerthumbnail_ = from._impl_.renderlargerthumbnail_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.showadattribution_ = from._impl_.showadattribution_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ContextInfo_ExternalAdReplyInfo::CopyFrom(const ContextInfo_ExternalAdReplyInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.ExternalAdReplyInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContextInfo_ExternalAdReplyInfo::IsInitialized() const {
+  return true;
+}
+
+void ContextInfo_ExternalAdReplyInfo::InternalSwap(ContextInfo_ExternalAdReplyInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailurl_, lhs_arena,
+      &other->_impl_.thumbnailurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediaurl_, lhs_arena,
+      &other->_impl_.mediaurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnail_, lhs_arena,
+      &other->_impl_.thumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sourcetype_, lhs_arena,
+      &other->_impl_.sourcetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sourceid_, lhs_arena,
+      &other->_impl_.sourceid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sourceurl_, lhs_arena,
+      &other->_impl_.sourceurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_)
+      + sizeof(ContextInfo_ExternalAdReplyInfo::_impl_.showadattribution_)
+      - PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_)>(
+          reinterpret_cast<char*>(&_impl_.mediatype_),
+          reinterpret_cast<char*>(&other->_impl_.mediatype_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_ExternalAdReplyInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[23]);
+}
+
+// ===================================================================
+
+class ContextInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ContextInfo>()._impl_._has_bits_);
+  static void set_has_stanzaid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_participant(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message& quotedmessage(const ContextInfo* msg);
+  static void set_has_quotedmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_remotejid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_conversionsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_conversiondata(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_conversiondelayseconds(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_forwardingscore(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_isforwarded(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static const ::proto::ContextInfo_AdReplyInfo& quotedad(const ContextInfo* msg);
+  static void set_has_quotedad(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::MessageKey& placeholderkey(const ContextInfo* msg);
+  static void set_has_placeholderkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_expiration(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_ephemeralsharedsecret(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply(const ContextInfo* msg);
+  static void set_has_externaladreply(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_entrypointconversionsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_entrypointconversionapp(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_entrypointconversiondelayseconds(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static const ::proto::DisappearingMode& disappearingmode(const ContextInfo* msg);
+  static void set_has_disappearingmode(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static const ::proto::ActionLink& actionlink(const ContextInfo* msg);
+  static void set_has_actionlink(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_groupsubject(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_parentgroupjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+const ::proto::Message&
+ContextInfo::_Internal::quotedmessage(const ContextInfo* msg) {
+  return *msg->_impl_.quotedmessage_;
+}
+const ::proto::ContextInfo_AdReplyInfo&
+ContextInfo::_Internal::quotedad(const ContextInfo* msg) {
+  return *msg->_impl_.quotedad_;
+}
+const ::proto::MessageKey&
+ContextInfo::_Internal::placeholderkey(const ContextInfo* msg) {
+  return *msg->_impl_.placeholderkey_;
+}
+const ::proto::ContextInfo_ExternalAdReplyInfo&
+ContextInfo::_Internal::externaladreply(const ContextInfo* msg) {
+  return *msg->_impl_.externaladreply_;
+}
+const ::proto::DisappearingMode&
+ContextInfo::_Internal::disappearingmode(const ContextInfo* msg) {
+  return *msg->_impl_.disappearingmode_;
+}
+const ::proto::ActionLink&
+ContextInfo::_Internal::actionlink(const ContextInfo* msg) {
+  return *msg->_impl_.actionlink_;
+}
+ContextInfo::ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ContextInfo)
+}
+ContextInfo::ContextInfo(const ContextInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ContextInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mentionedjid_){from._impl_.mentionedjid_}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.remotejid_){}
+    , decltype(_impl_.conversionsource_){}
+    , decltype(_impl_.conversiondata_){}
+    , decltype(_impl_.ephemeralsharedsecret_){}
+    , decltype(_impl_.entrypointconversionsource_){}
+    , decltype(_impl_.entrypointconversionapp_){}
+    , decltype(_impl_.groupsubject_){}
+    , decltype(_impl_.parentgroupjid_){}
+    , decltype(_impl_.quotedmessage_){nullptr}
+    , decltype(_impl_.quotedad_){nullptr}
+    , decltype(_impl_.placeholderkey_){nullptr}
+    , decltype(_impl_.externaladreply_){nullptr}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.actionlink_){nullptr}
+    , decltype(_impl_.conversiondelayseconds_){}
+    , decltype(_impl_.forwardingscore_){}
+    , decltype(_impl_.isforwarded_){}
+    , decltype(_impl_.expiration_){}
+    , decltype(_impl_.ephemeralsettingtimestamp_){}
+    , decltype(_impl_.entrypointconversiondelayseconds_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_stanzaid()) {
+    _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_participant()) {
+    _this->_impl_.participant_.Set(from._internal_participant(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.remotejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_remotejid()) {
+    _this->_impl_.remotejid_.Set(from._internal_remotejid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.conversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_conversionsource()) {
+    _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.conversiondata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_conversiondata()) {
+    _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.ephemeralsharedsecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ephemeralsharedsecret()) {
+    _this->_impl_.ephemeralsharedsecret_.Set(from._internal_ephemeralsharedsecret(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.entrypointconversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_entrypointconversionsource()) {
+    _this->_impl_.entrypointconversionsource_.Set(from._internal_entrypointconversionsource(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.entrypointconversionapp_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_entrypointconversionapp()) {
+    _this->_impl_.entrypointconversionapp_.Set(from._internal_entrypointconversionapp(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.groupsubject_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupsubject_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupsubject()) {
+    _this->_impl_.groupsubject_.Set(from._internal_groupsubject(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.parentgroupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_parentgroupjid()) {
+    _this->_impl_.parentgroupjid_.Set(from._internal_parentgroupjid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_quotedmessage()) {
+    _this->_impl_.quotedmessage_ = new ::proto::Message(*from._impl_.quotedmessage_);
+  }
+  if (from._internal_has_quotedad()) {
+    _this->_impl_.quotedad_ = new ::proto::ContextInfo_AdReplyInfo(*from._impl_.quotedad_);
+  }
+  if (from._internal_has_placeholderkey()) {
+    _this->_impl_.placeholderkey_ = new ::proto::MessageKey(*from._impl_.placeholderkey_);
+  }
+  if (from._internal_has_externaladreply()) {
+    _this->_impl_.externaladreply_ = new ::proto::ContextInfo_ExternalAdReplyInfo(*from._impl_.externaladreply_);
+  }
+  if (from._internal_has_disappearingmode()) {
+    _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_);
+  }
+  if (from._internal_has_actionlink()) {
+    _this->_impl_.actionlink_ = new ::proto::ActionLink(*from._impl_.actionlink_);
+  }
+  ::memcpy(&_impl_.conversiondelayseconds_, &from._impl_.conversiondelayseconds_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.entrypointconversiondelayseconds_) -
+    reinterpret_cast<char*>(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_));
+  // @@protoc_insertion_point(copy_constructor:proto.ContextInfo)
+}
+
+inline void ContextInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mentionedjid_){arena}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.remotejid_){}
+    , decltype(_impl_.conversionsource_){}
+    , decltype(_impl_.conversiondata_){}
+    , decltype(_impl_.ephemeralsharedsecret_){}
+    , decltype(_impl_.entrypointconversionsource_){}
+    , decltype(_impl_.entrypointconversionapp_){}
+    , decltype(_impl_.groupsubject_){}
+    , decltype(_impl_.parentgroupjid_){}
+    , decltype(_impl_.quotedmessage_){nullptr}
+    , decltype(_impl_.quotedad_){nullptr}
+    , decltype(_impl_.placeholderkey_){nullptr}
+    , decltype(_impl_.externaladreply_){nullptr}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.actionlink_){nullptr}
+    , decltype(_impl_.conversiondelayseconds_){0u}
+    , decltype(_impl_.forwardingscore_){0u}
+    , decltype(_impl_.isforwarded_){false}
+    , decltype(_impl_.expiration_){0u}
+    , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}}
+    , decltype(_impl_.entrypointconversiondelayseconds_){0u}
+  };
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.remotejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.conversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.conversiondata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.ephemeralsharedsecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.entrypointconversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.entrypointconversionapp_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.groupsubject_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupsubject_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.parentgroupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ContextInfo::~ContextInfo() {
+  // @@protoc_insertion_point(destructor:proto.ContextInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ContextInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mentionedjid_.~RepeatedPtrField();
+  _impl_.stanzaid_.Destroy();
+  _impl_.participant_.Destroy();
+  _impl_.remotejid_.Destroy();
+  _impl_.conversionsource_.Destroy();
+  _impl_.conversiondata_.Destroy();
+  _impl_.ephemeralsharedsecret_.Destroy();
+  _impl_.entrypointconversionsource_.Destroy();
+  _impl_.entrypointconversionapp_.Destroy();
+  _impl_.groupsubject_.Destroy();
+  _impl_.parentgroupjid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.quotedmessage_;
+  if (this != internal_default_instance()) delete _impl_.quotedad_;
+  if (this != internal_default_instance()) delete _impl_.placeholderkey_;
+  if (this != internal_default_instance()) delete _impl_.externaladreply_;
+  if (this != internal_default_instance()) delete _impl_.disappearingmode_;
+  if (this != internal_default_instance()) delete _impl_.actionlink_;
+}
+
+void ContextInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ContextInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ContextInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.mentionedjid_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.stanzaid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.participant_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.remotejid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.conversionsource_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.conversiondata_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.ephemeralsharedsecret_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.entrypointconversionsource_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.entrypointconversionapp_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.groupsubject_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.parentgroupjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.quotedmessage_ != nullptr);
+      _impl_.quotedmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      GOOGLE_DCHECK(_impl_.quotedad_ != nullptr);
+      _impl_.quotedad_->Clear();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.placeholderkey_ != nullptr);
+      _impl_.placeholderkey_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.externaladreply_ != nullptr);
+      _impl_.externaladreply_->Clear();
+    }
+    if (cached_has_bits & 0x00004000u) {
+      GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr);
+      _impl_.disappearingmode_->Clear();
+    }
+    if (cached_has_bits & 0x00008000u) {
+      GOOGLE_DCHECK(_impl_.actionlink_ != nullptr);
+      _impl_.actionlink_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    ::memset(&_impl_.conversiondelayseconds_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.entrypointconversiondelayseconds_) -
+        reinterpret_cast<char*>(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string stanzaId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_stanzaid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.stanzaId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string participant = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_participant();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.participant");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message quotedMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quotedmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string remoteJid = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_remotejid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.remoteJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string mentionedJid = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_mentionedjid();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.ContextInfo.mentionedJid");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string conversionSource = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          auto str = _internal_mutable_conversionsource();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.conversionSource");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes conversionData = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_conversiondata();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 conversionDelaySeconds = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          _Internal::set_has_conversiondelayseconds(&has_bits);
+          _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 forwardingScore = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
+          _Internal::set_has_forwardingscore(&has_bits);
+          _impl_.forwardingscore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isForwarded = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          _Internal::set_has_isforwarded(&has_bits);
+          _impl_.isforwarded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quotedad(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MessageKey placeholderKey = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_placeholderkey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 expiration = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          _Internal::set_has_expiration(&has_bits);
+          _impl_.expiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 ephemeralSettingTimestamp = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
+          _Internal::set_has_ephemeralsettingtimestamp(&has_bits);
+          _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes ephemeralSharedSecret = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          auto str = _internal_mutable_ephemeralsharedsecret();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_externaladreply(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string entryPointConversionSource = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          auto str = _internal_mutable_entrypointconversionsource();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionSource");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string entryPointConversionApp = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
+          auto str = _internal_mutable_entrypointconversionapp();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionApp");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 entryPointConversionDelaySeconds = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _Internal::set_has_entrypointconversiondelayseconds(&has_bits);
+          _impl_.entrypointconversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.DisappearingMode disappearingMode = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ActionLink actionLink = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_actionlink(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string groupSubject = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_groupsubject();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.groupSubject");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string parentGroupJid = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_parentgroupjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ContextInfo.parentGroupJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ContextInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string stanzaId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_stanzaid().data(), static_cast<int>(this->_internal_stanzaid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.stanzaId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_stanzaid(), target);
+  }
+
+  // optional string participant = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_participant().data(), static_cast<int>(this->_internal_participant().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.participant");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_participant(), target);
+  }
+
+  // optional .proto.Message quotedMessage = 3;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::quotedmessage(this),
+        _Internal::quotedmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string remoteJid = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_remotejid().data(), static_cast<int>(this->_internal_remotejid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.remoteJid");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_remotejid(), target);
+  }
+
+  // repeated string mentionedJid = 15;
+  for (int i = 0, n = this->_internal_mentionedjid_size(); i < n; i++) {
+    const auto& s = this->_internal_mentionedjid(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.mentionedJid");
+    target = stream->WriteString(15, s, target);
+  }
+
+  // optional string conversionSource = 18;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_conversionsource().data(), static_cast<int>(this->_internal_conversionsource().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.conversionSource");
+    target = stream->WriteStringMaybeAliased(
+        18, this->_internal_conversionsource(), target);
+  }
+
+  // optional bytes conversionData = 19;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        19, this->_internal_conversiondata(), target);
+  }
+
+  // optional uint32 conversionDelaySeconds = 20;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_conversiondelayseconds(), target);
+  }
+
+  // optional uint32 forwardingScore = 21;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(21, this->_internal_forwardingscore(), target);
+  }
+
+  // optional bool isForwarded = 22;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_isforwarded(), target);
+  }
+
+  // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
+  if (cached_has_bits & 0x00000800u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(23, _Internal::quotedad(this),
+        _Internal::quotedad(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MessageKey placeholderKey = 24;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(24, _Internal::placeholderkey(this),
+        _Internal::placeholderkey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 expiration = 25;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_expiration(), target);
+  }
+
+  // optional int64 ephemeralSettingTimestamp = 26;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(26, this->_internal_ephemeralsettingtimestamp(), target);
+  }
+
+  // optional bytes ephemeralSharedSecret = 27;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        27, this->_internal_ephemeralsharedsecret(), target);
+  }
+
+  // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(28, _Internal::externaladreply(this),
+        _Internal::externaladreply(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string entryPointConversionSource = 29;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_entrypointconversionsource().data(), static_cast<int>(this->_internal_entrypointconversionsource().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.entryPointConversionSource");
+    target = stream->WriteStringMaybeAliased(
+        29, this->_internal_entrypointconversionsource(), target);
+  }
+
+  // optional string entryPointConversionApp = 30;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_entrypointconversionapp().data(), static_cast<int>(this->_internal_entrypointconversionapp().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.entryPointConversionApp");
+    target = stream->WriteStringMaybeAliased(
+        30, this->_internal_entrypointconversionapp(), target);
+  }
+
+  // optional uint32 entryPointConversionDelaySeconds = 31;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(31, this->_internal_entrypointconversiondelayseconds(), target);
+  }
+
+  // optional .proto.DisappearingMode disappearingMode = 32;
+  if (cached_has_bits & 0x00004000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(32, _Internal::disappearingmode(this),
+        _Internal::disappearingmode(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ActionLink actionLink = 33;
+  if (cached_has_bits & 0x00008000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(33, _Internal::actionlink(this),
+        _Internal::actionlink(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string groupSubject = 34;
+  if (cached_has_bits & 0x00000100u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupsubject().data(), static_cast<int>(this->_internal_groupsubject().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.groupSubject");
+    target = stream->WriteStringMaybeAliased(
+        34, this->_internal_groupsubject(), target);
+  }
+
+  // optional string parentGroupJid = 35;
+  if (cached_has_bits & 0x00000200u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_parentgroupjid().data(), static_cast<int>(this->_internal_parentgroupjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ContextInfo.parentGroupJid");
+    target = stream->WriteStringMaybeAliased(
+        35, this->_internal_parentgroupjid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ContextInfo)
+  return target;
+}
+
+size_t ContextInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string mentionedJid = 15;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.mentionedjid_.size());
+  for (int i = 0, n = _impl_.mentionedjid_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.mentionedjid_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string stanzaId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_stanzaid());
+    }
+
+    // optional string participant = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_participant());
+    }
+
+    // optional string remoteJid = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_remotejid());
+    }
+
+    // optional string conversionSource = 18;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_conversionsource());
+    }
+
+    // optional bytes conversionData = 19;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_conversiondata());
+    }
+
+    // optional bytes ephemeralSharedSecret = 27;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_ephemeralsharedsecret());
+    }
+
+    // optional string entryPointConversionSource = 29;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_entrypointconversionsource());
+    }
+
+    // optional string entryPointConversionApp = 30;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_entrypointconversionapp());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional string groupSubject = 34;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupsubject());
+    }
+
+    // optional string parentGroupJid = 35;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_parentgroupjid());
+    }
+
+    // optional .proto.Message quotedMessage = 3;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quotedmessage_);
+    }
+
+    // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quotedad_);
+    }
+
+    // optional .proto.MessageKey placeholderKey = 24;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.placeholderkey_);
+    }
+
+    // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.externaladreply_);
+    }
+
+    // optional .proto.DisappearingMode disappearingMode = 32;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.disappearingmode_);
+    }
+
+    // optional .proto.ActionLink actionLink = 33;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.actionlink_);
+    }
+
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    // optional uint32 conversionDelaySeconds = 20;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_conversiondelayseconds());
+    }
+
+    // optional uint32 forwardingScore = 21;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_forwardingscore());
+    }
+
+    // optional bool isForwarded = 22;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint32 expiration = 25;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_expiration());
+    }
+
+    // optional int64 ephemeralSettingTimestamp = 26;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int64Size(
+          this->_internal_ephemeralsettingtimestamp());
+    }
+
+    // optional uint32 entryPointConversionDelaySeconds = 31;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_entrypointconversiondelayseconds());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ContextInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo::GetClassData() const { return &_class_data_; }
+
+
+void ContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ContextInfo*>(&to_msg);
+  auto& from = static_cast<const ContextInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.mentionedjid_.MergeFrom(from._impl_.mentionedjid_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_stanzaid(from._internal_stanzaid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_participant(from._internal_participant());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_remotejid(from._internal_remotejid());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_conversionsource(from._internal_conversionsource());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_conversiondata(from._internal_conversiondata());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_ephemeralsharedsecret(from._internal_ephemeralsharedsecret());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_entrypointconversionsource(from._internal_entrypointconversionsource());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_entrypointconversionapp(from._internal_entrypointconversionapp());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_groupsubject(from._internal_groupsubject());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_parentgroupjid(from._internal_parentgroupjid());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_quotedmessage()->::proto::Message::MergeFrom(
+          from._internal_quotedmessage());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_mutable_quotedad()->::proto::ContextInfo_AdReplyInfo::MergeFrom(
+          from._internal_quotedad());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_placeholderkey()->::proto::MessageKey::MergeFrom(
+          from._internal_placeholderkey());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_externaladreply()->::proto::ContextInfo_ExternalAdReplyInfo::MergeFrom(
+          from._internal_externaladreply());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom(
+          from._internal_disappearingmode());
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_internal_mutable_actionlink()->::proto::ActionLink::MergeFrom(
+          from._internal_actionlink());
+    }
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.forwardingscore_ = from._impl_.forwardingscore_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.isforwarded_ = from._impl_.isforwarded_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.expiration_ = from._impl_.expiration_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.entrypointconversiondelayseconds_ = from._impl_.entrypointconversiondelayseconds_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ContextInfo::CopyFrom(const ContextInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContextInfo::IsInitialized() const {
+  return true;
+}
+
+void ContextInfo::InternalSwap(ContextInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.mentionedjid_.InternalSwap(&other->_impl_.mentionedjid_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.stanzaid_, lhs_arena,
+      &other->_impl_.stanzaid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.participant_, lhs_arena,
+      &other->_impl_.participant_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.remotejid_, lhs_arena,
+      &other->_impl_.remotejid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.conversionsource_, lhs_arena,
+      &other->_impl_.conversionsource_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.conversiondata_, lhs_arena,
+      &other->_impl_.conversiondata_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ephemeralsharedsecret_, lhs_arena,
+      &other->_impl_.ephemeralsharedsecret_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.entrypointconversionsource_, lhs_arena,
+      &other->_impl_.entrypointconversionsource_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.entrypointconversionapp_, lhs_arena,
+      &other->_impl_.entrypointconversionapp_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupsubject_, lhs_arena,
+      &other->_impl_.groupsubject_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.parentgroupjid_, lhs_arena,
+      &other->_impl_.parentgroupjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.entrypointconversiondelayseconds_)
+      + sizeof(ContextInfo::_impl_.entrypointconversiondelayseconds_)
+      - PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.quotedmessage_)>(
+          reinterpret_cast<char*>(&_impl_.quotedmessage_),
+          reinterpret_cast<char*>(&other->_impl_.quotedmessage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[24]);
+}
+
+// ===================================================================
+
+class Conversation::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Conversation>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_newjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_oldjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_lastmsgtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_unreadcount(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_readonly(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_endofhistorytransfer(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_ephemeralexpiration(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_endofhistorytransfertype(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_conversationtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_phash(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_notspam(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_archived(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static const ::proto::DisappearingMode& disappearingmode(const Conversation* msg);
+  static void set_has_disappearingmode(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_unreadmentioncount(HasBits* has_bits) {
+    (*has_bits)[0] |= 16777216u;
+  }
+  static void set_has_markedasunread(HasBits* has_bits) {
+    (*has_bits)[0] |= 536870912u;
+  }
+  static void set_has_tctoken(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_tctokentimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 67108864u;
+  }
+  static void set_has_contactprimaryidentitykey(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_pinned(HasBits* has_bits) {
+    (*has_bits)[0] |= 33554432u;
+  }
+  static void set_has_muteendtime(HasBits* has_bits) {
+    (*has_bits)[0] |= 134217728u;
+  }
+  static const ::proto::WallpaperSettings& wallpaper(const Conversation* msg);
+  static void set_has_wallpaper(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_mediavisibility(HasBits* has_bits) {
+    (*has_bits)[0] |= 268435456u;
+  }
+  static void set_has_tctokensendertimestamp(HasBits* has_bits) {
+    (*has_bits)[1] |= 2u;
+  }
+  static void set_has_suspended(HasBits* has_bits) {
+    (*has_bits)[0] |= 1073741824u;
+  }
+  static void set_has_terminated(HasBits* has_bits) {
+    (*has_bits)[0] |= 2147483648u;
+  }
+  static void set_has_createdat(HasBits* has_bits) {
+    (*has_bits)[1] |= 4u;
+  }
+  static void set_has_createdby(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_support(HasBits* has_bits) {
+    (*has_bits)[1] |= 1u;
+  }
+  static void set_has_isparentgroup(HasBits* has_bits) {
+    (*has_bits)[1] |= 8u;
+  }
+  static void set_has_isdefaultsubgroup(HasBits* has_bits) {
+    (*has_bits)[1] |= 16u;
+  }
+  static void set_has_parentgroupid(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_displayname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_pnjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_selfpnexposed(HasBits* has_bits) {
+    (*has_bits)[1] |= 32u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+const ::proto::DisappearingMode&
+Conversation::_Internal::disappearingmode(const Conversation* msg) {
+  return *msg->_impl_.disappearingmode_;
+}
+const ::proto::WallpaperSettings&
+Conversation::_Internal::wallpaper(const Conversation* msg) {
+  return *msg->_impl_.wallpaper_;
+}
+Conversation::Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Conversation)
+}
+Conversation::Conversation(const Conversation& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Conversation* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messages_){from._impl_.messages_}
+    , decltype(_impl_.participant_){from._impl_.participant_}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.newjid_){}
+    , decltype(_impl_.oldjid_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.phash_){}
+    , decltype(_impl_.tctoken_){}
+    , decltype(_impl_.contactprimaryidentitykey_){}
+    , decltype(_impl_.createdby_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.parentgroupid_){}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.pnjid_){}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.wallpaper_){nullptr}
+    , decltype(_impl_.lastmsgtimestamp_){}
+    , decltype(_impl_.unreadcount_){}
+    , decltype(_impl_.ephemeralexpiration_){}
+    , decltype(_impl_.ephemeralsettingtimestamp_){}
+    , decltype(_impl_.endofhistorytransfertype_){}
+    , decltype(_impl_.readonly_){}
+    , decltype(_impl_.endofhistorytransfer_){}
+    , decltype(_impl_.notspam_){}
+    , decltype(_impl_.archived_){}
+    , decltype(_impl_.conversationtimestamp_){}
+    , decltype(_impl_.unreadmentioncount_){}
+    , decltype(_impl_.pinned_){}
+    , decltype(_impl_.tctokentimestamp_){}
+    , decltype(_impl_.muteendtime_){}
+    , decltype(_impl_.mediavisibility_){}
+    , decltype(_impl_.markedasunread_){}
+    , decltype(_impl_.suspended_){}
+    , decltype(_impl_.terminated_){}
+    , decltype(_impl_.support_){}
+    , decltype(_impl_.tctokensendertimestamp_){}
+    , decltype(_impl_.createdat_){}
+    , decltype(_impl_.isparentgroup_){}
+    , decltype(_impl_.isdefaultsubgroup_){}
+    , decltype(_impl_.selfpnexposed_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.newjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.newjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_newjid()) {
+    _this->_impl_.newjid_.Set(from._internal_newjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.oldjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.oldjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_oldjid()) {
+    _this->_impl_.oldjid_.Set(from._internal_oldjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.phash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_phash()) {
+    _this->_impl_.phash_.Set(from._internal_phash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.tctoken_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tctoken_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_tctoken()) {
+    _this->_impl_.tctoken_.Set(from._internal_tctoken(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.contactprimaryidentitykey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_contactprimaryidentitykey()) {
+    _this->_impl_.contactprimaryidentitykey_.Set(from._internal_contactprimaryidentitykey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.createdby_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.createdby_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_createdby()) {
+    _this->_impl_.createdby_.Set(from._internal_createdby(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.parentgroupid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_parentgroupid()) {
+    _this->_impl_.parentgroupid_.Set(from._internal_parentgroupid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displayname()) {
+    _this->_impl_.displayname_.Set(from._internal_displayname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pnjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pnjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pnjid()) {
+    _this->_impl_.pnjid_.Set(from._internal_pnjid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_disappearingmode()) {
+    _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_);
+  }
+  if (from._internal_has_wallpaper()) {
+    _this->_impl_.wallpaper_ = new ::proto::WallpaperSettings(*from._impl_.wallpaper_);
+  }
+  ::memcpy(&_impl_.lastmsgtimestamp_, &from._impl_.lastmsgtimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.selfpnexposed_) -
+    reinterpret_cast<char*>(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.selfpnexposed_));
+  // @@protoc_insertion_point(copy_constructor:proto.Conversation)
+}
+
+inline void Conversation::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messages_){arena}
+    , decltype(_impl_.participant_){arena}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.newjid_){}
+    , decltype(_impl_.oldjid_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.phash_){}
+    , decltype(_impl_.tctoken_){}
+    , decltype(_impl_.contactprimaryidentitykey_){}
+    , decltype(_impl_.createdby_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.parentgroupid_){}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.pnjid_){}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.wallpaper_){nullptr}
+    , decltype(_impl_.lastmsgtimestamp_){uint64_t{0u}}
+    , decltype(_impl_.unreadcount_){0u}
+    , decltype(_impl_.ephemeralexpiration_){0u}
+    , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}}
+    , decltype(_impl_.endofhistorytransfertype_){0}
+    , decltype(_impl_.readonly_){false}
+    , decltype(_impl_.endofhistorytransfer_){false}
+    , decltype(_impl_.notspam_){false}
+    , decltype(_impl_.archived_){false}
+    , decltype(_impl_.conversationtimestamp_){uint64_t{0u}}
+    , decltype(_impl_.unreadmentioncount_){0u}
+    , decltype(_impl_.pinned_){0u}
+    , decltype(_impl_.tctokentimestamp_){uint64_t{0u}}
+    , decltype(_impl_.muteendtime_){uint64_t{0u}}
+    , decltype(_impl_.mediavisibility_){0}
+    , decltype(_impl_.markedasunread_){false}
+    , decltype(_impl_.suspended_){false}
+    , decltype(_impl_.terminated_){false}
+    , decltype(_impl_.support_){false}
+    , decltype(_impl_.tctokensendertimestamp_){uint64_t{0u}}
+    , decltype(_impl_.createdat_){uint64_t{0u}}
+    , decltype(_impl_.isparentgroup_){false}
+    , decltype(_impl_.isdefaultsubgroup_){false}
+    , decltype(_impl_.selfpnexposed_){false}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.newjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.newjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.oldjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.oldjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.phash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.tctoken_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tctoken_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.contactprimaryidentitykey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.createdby_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.createdby_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.parentgroupid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pnjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pnjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Conversation::~Conversation() {
+  // @@protoc_insertion_point(destructor:proto.Conversation)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Conversation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.messages_.~RepeatedPtrField();
+  _impl_.participant_.~RepeatedPtrField();
+  _impl_.id_.Destroy();
+  _impl_.newjid_.Destroy();
+  _impl_.oldjid_.Destroy();
+  _impl_.name_.Destroy();
+  _impl_.phash_.Destroy();
+  _impl_.tctoken_.Destroy();
+  _impl_.contactprimaryidentitykey_.Destroy();
+  _impl_.createdby_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.parentgroupid_.Destroy();
+  _impl_.displayname_.Destroy();
+  _impl_.pnjid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.disappearingmode_;
+  if (this != internal_default_instance()) delete _impl_.wallpaper_;
+}
+
+void Conversation::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Conversation::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Conversation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.messages_.Clear();
+  _impl_.participant_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.newjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.oldjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.phash_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.tctoken_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.contactprimaryidentitykey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.createdby_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.parentgroupid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.displayname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.pnjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr);
+      _impl_.disappearingmode_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.wallpaper_ != nullptr);
+      _impl_.wallpaper_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000c000u) {
+    ::memset(&_impl_.lastmsgtimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.unreadcount_) -
+        reinterpret_cast<char*>(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.unreadcount_));
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    ::memset(&_impl_.ephemeralexpiration_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.conversationtimestamp_) -
+        reinterpret_cast<char*>(&_impl_.ephemeralexpiration_)) + sizeof(_impl_.conversationtimestamp_));
+  }
+  if (cached_has_bits & 0xff000000u) {
+    ::memset(&_impl_.unreadmentioncount_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.terminated_) -
+        reinterpret_cast<char*>(&_impl_.unreadmentioncount_)) + sizeof(_impl_.terminated_));
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    ::memset(&_impl_.support_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.selfpnexposed_) -
+        reinterpret_cast<char*>(&_impl_.support_)) + sizeof(_impl_.selfpnexposed_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Conversation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.HistorySyncMsg messages = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_messages(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string newJid = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_newjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.newJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string oldJid = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_oldjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.oldJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 lastMsgTimestamp = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_lastmsgtimestamp(&_impl_._has_bits_);
+          _impl_.lastmsgtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 unreadCount = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_unreadcount(&_impl_._has_bits_);
+          _impl_.unreadcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool readOnly = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_readonly(&_impl_._has_bits_);
+          _impl_.readonly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool endOfHistoryTransfer = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_endofhistorytransfer(&_impl_._has_bits_);
+          _impl_.endofhistorytransfer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 ephemeralExpiration = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_ephemeralexpiration(&_impl_._has_bits_);
+          _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 ephemeralSettingTimestamp = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_ephemeralsettingtimestamp(&_impl_._has_bits_);
+          _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Conversation_EndOfHistoryTransferType_IsValid(val))) {
+            _internal_set_endofhistorytransfertype(static_cast<::proto::Conversation_EndOfHistoryTransferType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 conversationTimestamp = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_conversationtimestamp(&_impl_._has_bits_);
+          _impl_.conversationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string name = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pHash = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          auto str = _internal_mutable_phash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.pHash");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool notSpam = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
+          _Internal::set_has_notspam(&_impl_._has_bits_);
+          _impl_.notspam_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool archived = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_archived(&_impl_._has_bits_);
+          _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.DisappearingMode disappearingMode = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 unreadMentionCount = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_unreadmentioncount(&_impl_._has_bits_);
+          _impl_.unreadmentioncount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool markedAsUnread = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
+          _Internal::set_has_markedasunread(&_impl_._has_bits_);
+          _impl_.markedasunread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.GroupParticipant participant = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_participant(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes tcToken = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_tctoken();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 tcTokenTimestamp = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          _Internal::set_has_tctokentimestamp(&_impl_._has_bits_);
+          _impl_.tctokentimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes contactPrimaryIdentityKey = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          auto str = _internal_mutable_contactprimaryidentitykey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 pinned = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
+          _Internal::set_has_pinned(&_impl_._has_bits_);
+          _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 muteEndTime = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          _Internal::set_has_muteendtime(&_impl_._has_bits_);
+          _impl_.muteendtime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WallpaperSettings wallpaper = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          ptr = ctx->ParseMessage(_internal_mutable_wallpaper(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaVisibility mediaVisibility = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) {
+            _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 tcTokenSenderTimestamp = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
+          _Internal::set_has_tctokensendertimestamp(&_impl_._has_bits_);
+          _impl_.tctokensendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool suspended = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
+          _Internal::set_has_suspended(&_impl_._has_bits_);
+          _impl_.suspended_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool terminated = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
+          _Internal::set_has_terminated(&_impl_._has_bits_);
+          _impl_.terminated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 createdAt = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _Internal::set_has_createdat(&_impl_._has_bits_);
+          _impl_.createdat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string createdBy = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          auto str = _internal_mutable_createdby();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.createdBy");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool support = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_support(&_impl_._has_bits_);
+          _impl_.support_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isParentGroup = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_isparentgroup(&_impl_._has_bits_);
+          _impl_.isparentgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isDefaultSubgroup = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_isdefaultsubgroup(&_impl_._has_bits_);
+          _impl_.isdefaultsubgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string parentGroupId = 37;
+      case 37:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_parentgroupid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.parentGroupId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string displayName = 38;
+      case 38:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_displayname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.displayName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pnJid = 39;
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_pnjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Conversation.pnJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool selfPnExposed = 40;
+      case 40:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_selfpnexposed(&_impl_._has_bits_);
+          _impl_.selfpnexposed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Conversation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Conversation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.id");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  // repeated .proto.HistorySyncMsg messages = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_messages_size()); i < n; i++) {
+    const auto& repfield = this->_internal_messages(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string newJid = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_newjid().data(), static_cast<int>(this->_internal_newjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.newJid");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_newjid(), target);
+  }
+
+  // optional string oldJid = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_oldjid().data(), static_cast<int>(this->_internal_oldjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.oldJid");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_oldjid(), target);
+  }
+
+  // optional uint64 lastMsgTimestamp = 5;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_lastmsgtimestamp(), target);
+  }
+
+  // optional uint32 unreadCount = 6;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_unreadcount(), target);
+  }
+
+  // optional bool readOnly = 7;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_readonly(), target);
+  }
+
+  // optional bool endOfHistoryTransfer = 8;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_endofhistorytransfer(), target);
+  }
+
+  // optional uint32 ephemeralExpiration = 9;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_ephemeralexpiration(), target);
+  }
+
+  // optional int64 ephemeralSettingTimestamp = 10;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_ephemeralsettingtimestamp(), target);
+  }
+
+  // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      11, this->_internal_endofhistorytransfertype(), target);
+  }
+
+  // optional uint64 conversationTimestamp = 12;
+  if (cached_has_bits & 0x00800000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(12, this->_internal_conversationtimestamp(), target);
+  }
+
+  // optional string name = 13;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.name");
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_name(), target);
+  }
+
+  // optional string pHash = 14;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_phash().data(), static_cast<int>(this->_internal_phash().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.pHash");
+    target = stream->WriteStringMaybeAliased(
+        14, this->_internal_phash(), target);
+  }
+
+  // optional bool notSpam = 15;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(15, this->_internal_notspam(), target);
+  }
+
+  // optional bool archived = 16;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_archived(), target);
+  }
+
+  // optional .proto.DisappearingMode disappearingMode = 17;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::disappearingmode(this),
+        _Internal::disappearingmode(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 unreadMentionCount = 18;
+  if (cached_has_bits & 0x01000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_unreadmentioncount(), target);
+  }
+
+  // optional bool markedAsUnread = 19;
+  if (cached_has_bits & 0x20000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(19, this->_internal_markedasunread(), target);
+  }
+
+  // repeated .proto.GroupParticipant participant = 20;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_participant_size()); i < n; i++) {
+    const auto& repfield = this->_internal_participant(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(20, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bytes tcToken = 21;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        21, this->_internal_tctoken(), target);
+  }
+
+  // optional uint64 tcTokenTimestamp = 22;
+  if (cached_has_bits & 0x04000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(22, this->_internal_tctokentimestamp(), target);
+  }
+
+  // optional bytes contactPrimaryIdentityKey = 23;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        23, this->_internal_contactprimaryidentitykey(), target);
+  }
+
+  // optional uint32 pinned = 24;
+  if (cached_has_bits & 0x02000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_pinned(), target);
+  }
+
+  // optional uint64 muteEndTime = 25;
+  if (cached_has_bits & 0x08000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(25, this->_internal_muteendtime(), target);
+  }
+
+  // optional .proto.WallpaperSettings wallpaper = 26;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(26, _Internal::wallpaper(this),
+        _Internal::wallpaper(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MediaVisibility mediaVisibility = 27;
+  if (cached_has_bits & 0x10000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      27, this->_internal_mediavisibility(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional uint64 tcTokenSenderTimestamp = 28;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(28, this->_internal_tctokensendertimestamp(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool suspended = 29;
+  if (cached_has_bits & 0x40000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(29, this->_internal_suspended(), target);
+  }
+
+  // optional bool terminated = 30;
+  if (cached_has_bits & 0x80000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(30, this->_internal_terminated(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional uint64 createdAt = 31;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_createdat(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string createdBy = 32;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_createdby().data(), static_cast<int>(this->_internal_createdby().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.createdBy");
+    target = stream->WriteStringMaybeAliased(
+        32, this->_internal_createdby(), target);
+  }
+
+  // optional string description = 33;
+  if (cached_has_bits & 0x00000100u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.description");
+    target = stream->WriteStringMaybeAliased(
+        33, this->_internal_description(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional bool support = 34;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_support(), target);
+  }
+
+  // optional bool isParentGroup = 35;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_isparentgroup(), target);
+  }
+
+  // optional bool isDefaultSubgroup = 36;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(36, this->_internal_isdefaultsubgroup(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string parentGroupId = 37;
+  if (cached_has_bits & 0x00000200u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_parentgroupid().data(), static_cast<int>(this->_internal_parentgroupid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.parentGroupId");
+    target = stream->WriteStringMaybeAliased(
+        37, this->_internal_parentgroupid(), target);
+  }
+
+  // optional string displayName = 38;
+  if (cached_has_bits & 0x00000400u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displayname().data(), static_cast<int>(this->_internal_displayname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.displayName");
+    target = stream->WriteStringMaybeAliased(
+        38, this->_internal_displayname(), target);
+  }
+
+  // optional string pnJid = 39;
+  if (cached_has_bits & 0x00000800u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pnjid().data(), static_cast<int>(this->_internal_pnjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Conversation.pnJid");
+    target = stream->WriteStringMaybeAliased(
+        39, this->_internal_pnjid(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional bool selfPnExposed = 40;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(40, this->_internal_selfpnexposed(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Conversation)
+  return target;
+}
+
+size_t Conversation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Conversation)
+  size_t total_size = 0;
+
+  // required string id = 1;
+  if (_internal_has_id()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_id());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.HistorySyncMsg messages = 2;
+  total_size += 1UL * this->_internal_messages_size();
+  for (const auto& msg : this->_impl_.messages_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.GroupParticipant participant = 20;
+  total_size += 2UL * this->_internal_participant_size();
+  for (const auto& msg : this->_impl_.participant_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000feu) {
+    // optional string newJid = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_newjid());
+    }
+
+    // optional string oldJid = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_oldjid());
+    }
+
+    // optional string name = 13;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string pHash = 14;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_phash());
+    }
+
+    // optional bytes tcToken = 21;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_tctoken());
+    }
+
+    // optional bytes contactPrimaryIdentityKey = 23;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_contactprimaryidentitykey());
+    }
+
+    // optional string createdBy = 32;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_createdby());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional string description = 33;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string parentGroupId = 37;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_parentgroupid());
+    }
+
+    // optional string displayName = 38;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displayname());
+    }
+
+    // optional string pnJid = 39;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pnjid());
+    }
+
+    // optional .proto.DisappearingMode disappearingMode = 17;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.disappearingmode_);
+    }
+
+    // optional .proto.WallpaperSettings wallpaper = 26;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.wallpaper_);
+    }
+
+    // optional uint64 lastMsgTimestamp = 5;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_lastmsgtimestamp());
+    }
+
+    // optional uint32 unreadCount = 6;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadcount());
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional uint32 ephemeralExpiration = 9;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration());
+    }
+
+    // optional int64 ephemeralSettingTimestamp = 10;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp());
+    }
+
+    // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_endofhistorytransfertype());
+    }
+
+    // optional bool readOnly = 7;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool endOfHistoryTransfer = 8;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool notSpam = 15;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool archived = 16;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint64 conversationTimestamp = 12;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_conversationtimestamp());
+    }
+
+  }
+  if (cached_has_bits & 0xff000000u) {
+    // optional uint32 unreadMentionCount = 18;
+    if (cached_has_bits & 0x01000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_unreadmentioncount());
+    }
+
+    // optional uint32 pinned = 24;
+    if (cached_has_bits & 0x02000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_pinned());
+    }
+
+    // optional uint64 tcTokenTimestamp = 22;
+    if (cached_has_bits & 0x04000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_tctokentimestamp());
+    }
+
+    // optional uint64 muteEndTime = 25;
+    if (cached_has_bits & 0x08000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_muteendtime());
+    }
+
+    // optional .proto.MediaVisibility mediaVisibility = 27;
+    if (cached_has_bits & 0x10000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility());
+    }
+
+    // optional bool markedAsUnread = 19;
+    if (cached_has_bits & 0x20000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool suspended = 29;
+    if (cached_has_bits & 0x40000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool terminated = 30;
+    if (cached_has_bits & 0x80000000u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional bool support = 34;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint64 tcTokenSenderTimestamp = 28;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_tctokensendertimestamp());
+    }
+
+    // optional uint64 createdAt = 31;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_createdat());
+    }
+
+    // optional bool isParentGroup = 35;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool isDefaultSubgroup = 36;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool selfPnExposed = 40;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Conversation::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Conversation::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Conversation::GetClassData() const { return &_class_data_; }
+
+
+void Conversation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Conversation*>(&to_msg);
+  auto& from = static_cast<const Conversation&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Conversation)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.messages_.MergeFrom(from._impl_.messages_);
+  _this->_impl_.participant_.MergeFrom(from._impl_.participant_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_newjid(from._internal_newjid());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_oldjid(from._internal_oldjid());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_phash(from._internal_phash());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_tctoken(from._internal_tctoken());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_contactprimaryidentitykey(from._internal_contactprimaryidentitykey());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_createdby(from._internal_createdby());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_parentgroupid(from._internal_parentgroupid());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_displayname(from._internal_displayname());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_pnjid(from._internal_pnjid());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom(
+          from._internal_disappearingmode());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_wallpaper()->::proto::WallpaperSettings::MergeFrom(
+          from._internal_wallpaper());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.lastmsgtimestamp_ = from._impl_.lastmsgtimestamp_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.unreadcount_ = from._impl_.unreadcount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.endofhistorytransfertype_ = from._impl_.endofhistorytransfertype_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.readonly_ = from._impl_.readonly_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.endofhistorytransfer_ = from._impl_.endofhistorytransfer_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.notspam_ = from._impl_.notspam_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.archived_ = from._impl_.archived_;
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_impl_.conversationtimestamp_ = from._impl_.conversationtimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0xff000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      _this->_impl_.unreadmentioncount_ = from._impl_.unreadmentioncount_;
+    }
+    if (cached_has_bits & 0x02000000u) {
+      _this->_impl_.pinned_ = from._impl_.pinned_;
+    }
+    if (cached_has_bits & 0x04000000u) {
+      _this->_impl_.tctokentimestamp_ = from._impl_.tctokentimestamp_;
+    }
+    if (cached_has_bits & 0x08000000u) {
+      _this->_impl_.muteendtime_ = from._impl_.muteendtime_;
+    }
+    if (cached_has_bits & 0x10000000u) {
+      _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_;
+    }
+    if (cached_has_bits & 0x20000000u) {
+      _this->_impl_.markedasunread_ = from._impl_.markedasunread_;
+    }
+    if (cached_has_bits & 0x40000000u) {
+      _this->_impl_.suspended_ = from._impl_.suspended_;
+    }
+    if (cached_has_bits & 0x80000000u) {
+      _this->_impl_.terminated_ = from._impl_.terminated_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  cached_has_bits = from._impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.support_ = from._impl_.support_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.tctokensendertimestamp_ = from._impl_.tctokensendertimestamp_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.createdat_ = from._impl_.createdat_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.isparentgroup_ = from._impl_.isparentgroup_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.isdefaultsubgroup_ = from._impl_.isdefaultsubgroup_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.selfpnexposed_ = from._impl_.selfpnexposed_;
+    }
+    _this->_impl_._has_bits_[1] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Conversation::CopyFrom(const Conversation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Conversation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Conversation::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.messages_))
+    return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.participant_))
+    return false;
+  return true;
+}
+
+void Conversation::InternalSwap(Conversation* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]);
+  _impl_.messages_.InternalSwap(&other->_impl_.messages_);
+  _impl_.participant_.InternalSwap(&other->_impl_.participant_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.newjid_, lhs_arena,
+      &other->_impl_.newjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.oldjid_, lhs_arena,
+      &other->_impl_.oldjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.phash_, lhs_arena,
+      &other->_impl_.phash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.tctoken_, lhs_arena,
+      &other->_impl_.tctoken_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.contactprimaryidentitykey_, lhs_arena,
+      &other->_impl_.contactprimaryidentitykey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.createdby_, lhs_arena,
+      &other->_impl_.createdby_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.parentgroupid_, lhs_arena,
+      &other->_impl_.parentgroupid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displayname_, lhs_arena,
+      &other->_impl_.displayname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pnjid_, lhs_arena,
+      &other->_impl_.pnjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Conversation, _impl_.selfpnexposed_)
+      + sizeof(Conversation::_impl_.selfpnexposed_)
+      - PROTOBUF_FIELD_OFFSET(Conversation, _impl_.disappearingmode_)>(
+          reinterpret_cast<char*>(&_impl_.disappearingmode_),
+          reinterpret_cast<char*>(&other->_impl_.disappearingmode_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Conversation::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[25]);
+}
+
+// ===================================================================
+
+class DeviceListMetadata::_Internal {
+ public:
+  using HasBits = decltype(std::declval<DeviceListMetadata>()._impl_._has_bits_);
+  static void set_has_senderkeyhash(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_sendertimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_recipientkeyhash(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_recipienttimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+DeviceListMetadata::DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.DeviceListMetadata)
+}
+DeviceListMetadata::DeviceListMetadata(const DeviceListMetadata& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  DeviceListMetadata* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.senderkeyindexes_){from._impl_.senderkeyindexes_}
+    , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.recipientkeyindexes_){from._impl_.recipientkeyindexes_}
+    , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.senderkeyhash_){}
+    , decltype(_impl_.recipientkeyhash_){}
+    , decltype(_impl_.sendertimestamp_){}
+    , decltype(_impl_.recipienttimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.senderkeyhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_senderkeyhash()) {
+    _this->_impl_.senderkeyhash_.Set(from._internal_senderkeyhash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.recipientkeyhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_recipientkeyhash()) {
+    _this->_impl_.recipientkeyhash_.Set(from._internal_recipientkeyhash(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.sendertimestamp_, &from._impl_.sendertimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.recipienttimestamp_) -
+    reinterpret_cast<char*>(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.DeviceListMetadata)
+}
+
+inline void DeviceListMetadata::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.senderkeyindexes_){arena}
+    , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.recipientkeyindexes_){arena}
+    , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.senderkeyhash_){}
+    , decltype(_impl_.recipientkeyhash_){}
+    , decltype(_impl_.sendertimestamp_){uint64_t{0u}}
+    , decltype(_impl_.recipienttimestamp_){uint64_t{0u}}
+  };
+  _impl_.senderkeyhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.recipientkeyhash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+DeviceListMetadata::~DeviceListMetadata() {
+  // @@protoc_insertion_point(destructor:proto.DeviceListMetadata)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void DeviceListMetadata::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.senderkeyindexes_.~RepeatedField();
+  _impl_.recipientkeyindexes_.~RepeatedField();
+  _impl_.senderkeyhash_.Destroy();
+  _impl_.recipientkeyhash_.Destroy();
+}
+
+void DeviceListMetadata::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void DeviceListMetadata::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.DeviceListMetadata)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.senderkeyindexes_.Clear();
+  _impl_.recipientkeyindexes_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.senderkeyhash_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.recipientkeyhash_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.sendertimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.recipienttimestamp_) -
+        reinterpret_cast<char*>(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DeviceListMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes senderKeyHash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_senderkeyhash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 senderTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_sendertimestamp(&has_bits);
+          _impl_.sendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 senderKeyIndexes = 3 [packed = true];
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_senderkeyindexes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 24) {
+          _internal_add_senderkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes recipientKeyHash = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_recipientkeyhash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 recipientTimestamp = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_recipienttimestamp(&has_bits);
+          _impl_.recipienttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 recipientKeyIndexes = 10 [packed = true];
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_recipientkeyindexes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 80) {
+          _internal_add_recipientkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DeviceListMetadata::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceListMetadata)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes senderKeyHash = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_senderkeyhash(), target);
+  }
+
+  // optional uint64 senderTimestamp = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sendertimestamp(), target);
+  }
+
+  // repeated uint32 senderKeyIndexes = 3 [packed = true];
+  {
+    int byte_size = _impl_._senderkeyindexes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt32Packed(
+          3, _internal_senderkeyindexes(), byte_size, target);
+    }
+  }
+
+  // optional bytes recipientKeyHash = 8;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_recipientkeyhash(), target);
+  }
+
+  // optional uint64 recipientTimestamp = 9;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_recipienttimestamp(), target);
+  }
+
+  // repeated uint32 recipientKeyIndexes = 10 [packed = true];
+  {
+    int byte_size = _impl_._recipientkeyindexes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt32Packed(
+          10, _internal_recipientkeyindexes(), byte_size, target);
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.DeviceListMetadata)
+  return target;
+}
+
+size_t DeviceListMetadata::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.DeviceListMetadata)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated uint32 senderKeyIndexes = 3 [packed = true];
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.senderkeyindexes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._senderkeyindexes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  // repeated uint32 recipientKeyIndexes = 10 [packed = true];
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.recipientkeyindexes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._recipientkeyindexes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes senderKeyHash = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_senderkeyhash());
+    }
+
+    // optional bytes recipientKeyHash = 8;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_recipientkeyhash());
+    }
+
+    // optional uint64 senderTimestamp = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sendertimestamp());
+    }
+
+    // optional uint64 recipientTimestamp = 9;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_recipienttimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceListMetadata::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    DeviceListMetadata::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceListMetadata::GetClassData() const { return &_class_data_; }
+
+
+void DeviceListMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<DeviceListMetadata*>(&to_msg);
+  auto& from = static_cast<const DeviceListMetadata&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceListMetadata)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.senderkeyindexes_.MergeFrom(from._impl_.senderkeyindexes_);
+  _this->_impl_.recipientkeyindexes_.MergeFrom(from._impl_.recipientkeyindexes_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_senderkeyhash(from._internal_senderkeyhash());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_recipientkeyhash(from._internal_recipientkeyhash());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.sendertimestamp_ = from._impl_.sendertimestamp_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.recipienttimestamp_ = from._impl_.recipienttimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DeviceListMetadata::CopyFrom(const DeviceListMetadata& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceListMetadata)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeviceListMetadata::IsInitialized() const {
+  return true;
+}
+
+void DeviceListMetadata::InternalSwap(DeviceListMetadata* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.senderkeyindexes_.InternalSwap(&other->_impl_.senderkeyindexes_);
+  _impl_.recipientkeyindexes_.InternalSwap(&other->_impl_.recipientkeyindexes_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.senderkeyhash_, lhs_arena,
+      &other->_impl_.senderkeyhash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.recipientkeyhash_, lhs_arena,
+      &other->_impl_.recipientkeyhash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.recipienttimestamp_)
+      + sizeof(DeviceListMetadata::_impl_.recipienttimestamp_)
+      - PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.sendertimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.sendertimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.sendertimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DeviceListMetadata::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[26]);
+}
+
+// ===================================================================
+
+class DeviceProps_AppVersion::_Internal {
+ public:
+  using HasBits = decltype(std::declval<DeviceProps_AppVersion>()._impl_._has_bits_);
+  static void set_has_primary(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_secondary(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_tertiary(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_quaternary(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_quinary(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+DeviceProps_AppVersion::DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.DeviceProps.AppVersion)
+}
+DeviceProps_AppVersion::DeviceProps_AppVersion(const DeviceProps_AppVersion& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  DeviceProps_AppVersion* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.primary_){}
+    , decltype(_impl_.secondary_){}
+    , decltype(_impl_.tertiary_){}
+    , decltype(_impl_.quaternary_){}
+    , decltype(_impl_.quinary_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.primary_, &from._impl_.primary_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.quinary_) -
+    reinterpret_cast<char*>(&_impl_.primary_)) + sizeof(_impl_.quinary_));
+  // @@protoc_insertion_point(copy_constructor:proto.DeviceProps.AppVersion)
+}
+
+inline void DeviceProps_AppVersion::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.primary_){0u}
+    , decltype(_impl_.secondary_){0u}
+    , decltype(_impl_.tertiary_){0u}
+    , decltype(_impl_.quaternary_){0u}
+    , decltype(_impl_.quinary_){0u}
+  };
+}
+
+DeviceProps_AppVersion::~DeviceProps_AppVersion() {
+  // @@protoc_insertion_point(destructor:proto.DeviceProps.AppVersion)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void DeviceProps_AppVersion::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void DeviceProps_AppVersion::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void DeviceProps_AppVersion::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.DeviceProps.AppVersion)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    ::memset(&_impl_.primary_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.quinary_) -
+        reinterpret_cast<char*>(&_impl_.primary_)) + sizeof(_impl_.quinary_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DeviceProps_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 primary = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_primary(&has_bits);
+          _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 secondary = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_secondary(&has_bits);
+          _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 tertiary = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_tertiary(&has_bits);
+          _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 quaternary = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_quaternary(&has_bits);
+          _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 quinary = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_quinary(&has_bits);
+          _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DeviceProps_AppVersion::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps.AppVersion)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 primary = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target);
+  }
+
+  // optional uint32 secondary = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target);
+  }
+
+  // optional uint32 tertiary = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target);
+  }
+
+  // optional uint32 quaternary = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target);
+  }
+
+  // optional uint32 quinary = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.DeviceProps.AppVersion)
+  return target;
+}
+
+size_t DeviceProps_AppVersion::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps.AppVersion)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional uint32 primary = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary());
+    }
+
+    // optional uint32 secondary = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary());
+    }
+
+    // optional uint32 tertiary = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary());
+    }
+
+    // optional uint32 quaternary = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary());
+    }
+
+    // optional uint32 quinary = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps_AppVersion::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    DeviceProps_AppVersion::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps_AppVersion::GetClassData() const { return &_class_data_; }
+
+
+void DeviceProps_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<DeviceProps_AppVersion*>(&to_msg);
+  auto& from = static_cast<const DeviceProps_AppVersion&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps.AppVersion)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.primary_ = from._impl_.primary_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.secondary_ = from._impl_.secondary_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.tertiary_ = from._impl_.tertiary_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.quaternary_ = from._impl_.quaternary_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.quinary_ = from._impl_.quinary_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DeviceProps_AppVersion::CopyFrom(const DeviceProps_AppVersion& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps.AppVersion)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeviceProps_AppVersion::IsInitialized() const {
+  return true;
+}
+
+void DeviceProps_AppVersion::InternalSwap(DeviceProps_AppVersion* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.quinary_)
+      + sizeof(DeviceProps_AppVersion::_impl_.quinary_)
+      - PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.primary_)>(
+          reinterpret_cast<char*>(&_impl_.primary_),
+          reinterpret_cast<char*>(&other->_impl_.primary_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps_AppVersion::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[27]);
+}
+
+// ===================================================================
+
+class DeviceProps::_Internal {
+ public:
+  using HasBits = decltype(std::declval<DeviceProps>()._impl_._has_bits_);
+  static void set_has_os(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::DeviceProps_AppVersion& version(const DeviceProps* msg);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_platformtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_requirefullsync(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::DeviceProps_AppVersion&
+DeviceProps::_Internal::version(const DeviceProps* msg) {
+  return *msg->_impl_.version_;
+}
+DeviceProps::DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.DeviceProps)
+}
+DeviceProps::DeviceProps(const DeviceProps& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  DeviceProps* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.os_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.platformtype_){}
+    , decltype(_impl_.requirefullsync_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.os_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_os()) {
+    _this->_impl_.os_.Set(from._internal_os(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_version()) {
+    _this->_impl_.version_ = new ::proto::DeviceProps_AppVersion(*from._impl_.version_);
+  }
+  ::memcpy(&_impl_.platformtype_, &from._impl_.platformtype_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.requirefullsync_) -
+    reinterpret_cast<char*>(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_));
+  // @@protoc_insertion_point(copy_constructor:proto.DeviceProps)
+}
+
+inline void DeviceProps::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.os_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.platformtype_){0}
+    , decltype(_impl_.requirefullsync_){false}
+  };
+  _impl_.os_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+DeviceProps::~DeviceProps() {
+  // @@protoc_insertion_point(destructor:proto.DeviceProps)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void DeviceProps::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.os_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.version_;
+}
+
+void DeviceProps::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void DeviceProps::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.DeviceProps)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.os_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.version_ != nullptr);
+      _impl_.version_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.platformtype_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.requirefullsync_) -
+        reinterpret_cast<char*>(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DeviceProps::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string os = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_os();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.DeviceProps.os");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.DeviceProps.AppVersion version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.DeviceProps.PlatformType platformType = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::DeviceProps_PlatformType_IsValid(val))) {
+            _internal_set_platformtype(static_cast<::proto::DeviceProps_PlatformType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool requireFullSync = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_requirefullsync(&has_bits);
+          _impl_.requirefullsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DeviceProps::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string os = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_os().data(), static_cast<int>(this->_internal_os().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.DeviceProps.os");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_os(), target);
+  }
+
+  // optional .proto.DeviceProps.AppVersion version = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::version(this),
+        _Internal::version(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.DeviceProps.PlatformType platformType = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_platformtype(), target);
+  }
+
+  // optional bool requireFullSync = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_requirefullsync(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.DeviceProps)
+  return target;
+}
+
+size_t DeviceProps::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string os = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_os());
+    }
+
+    // optional .proto.DeviceProps.AppVersion version = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.version_);
+    }
+
+    // optional .proto.DeviceProps.PlatformType platformType = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_platformtype());
+    }
+
+    // optional bool requireFullSync = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    DeviceProps::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps::GetClassData() const { return &_class_data_; }
+
+
+void DeviceProps::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<DeviceProps*>(&to_msg);
+  auto& from = static_cast<const DeviceProps&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_os(from._internal_os());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_version()->::proto::DeviceProps_AppVersion::MergeFrom(
+          from._internal_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.platformtype_ = from._impl_.platformtype_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.requirefullsync_ = from._impl_.requirefullsync_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DeviceProps::CopyFrom(const DeviceProps& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeviceProps::IsInitialized() const {
+  return true;
+}
+
+void DeviceProps::InternalSwap(DeviceProps* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.os_, lhs_arena,
+      &other->_impl_.os_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.requirefullsync_)
+      + sizeof(DeviceProps::_impl_.requirefullsync_)
+      - PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.version_)>(
+          reinterpret_cast<char*>(&_impl_.version_),
+          reinterpret_cast<char*>(&other->_impl_.version_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[28]);
+}
+
+// ===================================================================
+
+class DisappearingMode::_Internal {
+ public:
+  using HasBits = decltype(std::declval<DisappearingMode>()._impl_._has_bits_);
+  static void set_has_initiator(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+DisappearingMode::DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.DisappearingMode)
+}
+DisappearingMode::DisappearingMode(const DisappearingMode& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  DisappearingMode* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.initiator_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.initiator_ = from._impl_.initiator_;
+  // @@protoc_insertion_point(copy_constructor:proto.DisappearingMode)
+}
+
+inline void DisappearingMode::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.initiator_){0}
+  };
+}
+
+DisappearingMode::~DisappearingMode() {
+  // @@protoc_insertion_point(destructor:proto.DisappearingMode)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void DisappearingMode::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void DisappearingMode::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void DisappearingMode::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.DisappearingMode)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.initiator_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DisappearingMode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.DisappearingMode.Initiator initiator = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::DisappearingMode_Initiator_IsValid(val))) {
+            _internal_set_initiator(static_cast<::proto::DisappearingMode_Initiator>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DisappearingMode::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.DisappearingMode)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.DisappearingMode.Initiator initiator = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_initiator(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.DisappearingMode)
+  return target;
+}
+
+size_t DisappearingMode::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.DisappearingMode)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.DisappearingMode.Initiator initiator = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_initiator());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DisappearingMode::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    DisappearingMode::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DisappearingMode::GetClassData() const { return &_class_data_; }
+
+
+void DisappearingMode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<DisappearingMode*>(&to_msg);
+  auto& from = static_cast<const DisappearingMode&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.DisappearingMode)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_initiator()) {
+    _this->_internal_set_initiator(from._internal_initiator());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DisappearingMode::CopyFrom(const DisappearingMode& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.DisappearingMode)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DisappearingMode::IsInitialized() const {
+  return true;
+}
+
+void DisappearingMode::InternalSwap(DisappearingMode* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.initiator_, other->_impl_.initiator_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DisappearingMode::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[29]);
+}
+
+// ===================================================================
+
+class EphemeralSetting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<EphemeralSetting>()._impl_._has_bits_);
+  static void set_has_duration(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+EphemeralSetting::EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.EphemeralSetting)
+}
+EphemeralSetting::EphemeralSetting(const EphemeralSetting& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  EphemeralSetting* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){}
+    , decltype(_impl_.duration_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.duration_) -
+    reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.duration_));
+  // @@protoc_insertion_point(copy_constructor:proto.EphemeralSetting)
+}
+
+inline void EphemeralSetting::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+    , decltype(_impl_.duration_){0}
+  };
+}
+
+EphemeralSetting::~EphemeralSetting() {
+  // @@protoc_insertion_point(destructor:proto.EphemeralSetting)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void EphemeralSetting::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void EphemeralSetting::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void EphemeralSetting::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.EphemeralSetting)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.duration_) -
+        reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.duration_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* EphemeralSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional sfixed32 duration = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
+          _Internal::set_has_duration(&has_bits);
+          _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<int32_t>(ptr);
+          ptr += sizeof(int32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional sfixed64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<int64_t>(ptr);
+          ptr += sizeof(int64_t);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* EphemeralSetting::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.EphemeralSetting)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional sfixed32 duration = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(1, this->_internal_duration(), target);
+  }
+
+  // optional sfixed64 timestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteSFixed64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.EphemeralSetting)
+  return target;
+}
+
+size_t EphemeralSetting::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.EphemeralSetting)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional sfixed64 timestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 + 8;
+    }
+
+    // optional sfixed32 duration = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EphemeralSetting::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    EphemeralSetting::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EphemeralSetting::GetClassData() const { return &_class_data_; }
+
+
+void EphemeralSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<EphemeralSetting*>(&to_msg);
+  auto& from = static_cast<const EphemeralSetting&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.EphemeralSetting)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.duration_ = from._impl_.duration_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void EphemeralSetting::CopyFrom(const EphemeralSetting& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.EphemeralSetting)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EphemeralSetting::IsInitialized() const {
+  return true;
+}
+
+void EphemeralSetting::InternalSwap(EphemeralSetting* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.duration_)
+      + sizeof(EphemeralSetting::_impl_.duration_)
+      - PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.timestamp_)>(
+          reinterpret_cast<char*>(&_impl_.timestamp_),
+          reinterpret_cast<char*>(&other->_impl_.timestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata EphemeralSetting::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[30]);
+}
+
+// ===================================================================
+
+class ExitCode::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ExitCode>()._impl_._has_bits_);
+  static void set_has_code(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ExitCode::ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ExitCode)
+}
+ExitCode::ExitCode(const ExitCode& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ExitCode* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.code_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.code_ = from._impl_.code_;
+  // @@protoc_insertion_point(copy_constructor:proto.ExitCode)
+}
+
+inline void ExitCode::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.code_){uint64_t{0u}}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ExitCode::~ExitCode() {
+  // @@protoc_insertion_point(destructor:proto.ExitCode)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ExitCode::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+}
+
+void ExitCode::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ExitCode::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ExitCode)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.text_.ClearNonDefaultToEmpty();
+  }
+  _impl_.code_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ExitCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 code = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_code(&has_bits);
+          _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string text = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ExitCode.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ExitCode::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ExitCode)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 code = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_code(), target);
+  }
+
+  // optional string text = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ExitCode.text");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_text(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ExitCode)
+  return target;
+}
+
+size_t ExitCode::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ExitCode)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string text = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_text());
+    }
+
+    // optional uint64 code = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_code());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExitCode::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ExitCode::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExitCode::GetClassData() const { return &_class_data_; }
+
+
+void ExitCode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ExitCode*>(&to_msg);
+  auto& from = static_cast<const ExitCode&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExitCode)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_text(from._internal_text());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.code_ = from._impl_.code_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ExitCode::CopyFrom(const ExitCode& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExitCode)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ExitCode::IsInitialized() const {
+  return true;
+}
+
+void ExitCode::InternalSwap(ExitCode* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+  swap(_impl_.code_, other->_impl_.code_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ExitCode::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[31]);
+}
+
+// ===================================================================
+
+class ExternalBlobReference::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ExternalBlobReference>()._impl_._has_bits_);
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_handle(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_filesizebytes(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+ExternalBlobReference::ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ExternalBlobReference)
+}
+ExternalBlobReference::ExternalBlobReference(const ExternalBlobReference& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ExternalBlobReference* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.handle_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.filesizebytes_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.handle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.handle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_handle()) {
+    _this->_impl_.handle_.Set(from._internal_handle(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_;
+  // @@protoc_insertion_point(copy_constructor:proto.ExternalBlobReference)
+}
+
+inline void ExternalBlobReference::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.handle_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.filesizebytes_){uint64_t{0u}}
+  };
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.handle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.handle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ExternalBlobReference::~ExternalBlobReference() {
+  // @@protoc_insertion_point(destructor:proto.ExternalBlobReference)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ExternalBlobReference::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mediakey_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.handle_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+}
+
+void ExternalBlobReference::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ExternalBlobReference::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ExternalBlobReference)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.handle_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.filesizebytes_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ExternalBlobReference::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes mediaKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string handle = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_handle();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.handle");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileSizeBytes = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_filesizebytes(&has_bits);
+          _impl_.filesizebytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ExternalBlobReference::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ExternalBlobReference)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes mediaKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_mediakey(), target);
+  }
+
+  // optional string directPath = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ExternalBlobReference.directPath");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_directpath(), target);
+  }
+
+  // optional string handle = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_handle().data(), static_cast<int>(this->_internal_handle().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ExternalBlobReference.handle");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_handle(), target);
+  }
+
+  // optional uint64 fileSizeBytes = 4;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filesizebytes(), target);
+  }
+
+  // optional bytes fileSha256 = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_filesha256(), target);
+  }
+
+  // optional bytes fileEncSha256 = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_fileencsha256(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ExternalBlobReference)
+  return target;
+}
+
+size_t ExternalBlobReference::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ExternalBlobReference)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional bytes mediaKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string directPath = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional string handle = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_handle());
+    }
+
+    // optional bytes fileSha256 = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes fileEncSha256 = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional uint64 fileSizeBytes = 4;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filesizebytes());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExternalBlobReference::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ExternalBlobReference::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExternalBlobReference::GetClassData() const { return &_class_data_; }
+
+
+void ExternalBlobReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ExternalBlobReference*>(&to_msg);
+  auto& from = static_cast<const ExternalBlobReference&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExternalBlobReference)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_handle(from._internal_handle());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ExternalBlobReference::CopyFrom(const ExternalBlobReference& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExternalBlobReference)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ExternalBlobReference::IsInitialized() const {
+  return true;
+}
+
+void ExternalBlobReference::InternalSwap(ExternalBlobReference* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.handle_, lhs_arena,
+      &other->_impl_.handle_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  swap(_impl_.filesizebytes_, other->_impl_.filesizebytes_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ExternalBlobReference::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[32]);
+}
+
+// ===================================================================
+
+class GlobalSettings::_Internal {
+ public:
+  using HasBits = decltype(std::declval<GlobalSettings>()._impl_._has_bits_);
+  static const ::proto::WallpaperSettings& lightthemewallpaper(const GlobalSettings* msg);
+  static void set_has_lightthemewallpaper(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mediavisibility(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::WallpaperSettings& darkthemewallpaper(const GlobalSettings* msg);
+  static void set_has_darkthemewallpaper(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::AutoDownloadSettings& autodownloadwifi(const GlobalSettings* msg);
+  static void set_has_autodownloadwifi(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::AutoDownloadSettings& autodownloadcellular(const GlobalSettings* msg);
+  static void set_has_autodownloadcellular(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::AutoDownloadSettings& autodownloadroaming(const GlobalSettings* msg);
+  static void set_has_autodownloadroaming(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_showindividualnotificationspreview(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_showgroupnotificationspreview(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_disappearingmodeduration(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_disappearingmodetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+};
+
+const ::proto::WallpaperSettings&
+GlobalSettings::_Internal::lightthemewallpaper(const GlobalSettings* msg) {
+  return *msg->_impl_.lightthemewallpaper_;
+}
+const ::proto::WallpaperSettings&
+GlobalSettings::_Internal::darkthemewallpaper(const GlobalSettings* msg) {
+  return *msg->_impl_.darkthemewallpaper_;
+}
+const ::proto::AutoDownloadSettings&
+GlobalSettings::_Internal::autodownloadwifi(const GlobalSettings* msg) {
+  return *msg->_impl_.autodownloadwifi_;
+}
+const ::proto::AutoDownloadSettings&
+GlobalSettings::_Internal::autodownloadcellular(const GlobalSettings* msg) {
+  return *msg->_impl_.autodownloadcellular_;
+}
+const ::proto::AutoDownloadSettings&
+GlobalSettings::_Internal::autodownloadroaming(const GlobalSettings* msg) {
+  return *msg->_impl_.autodownloadroaming_;
+}
+GlobalSettings::GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.GlobalSettings)
+}
+GlobalSettings::GlobalSettings(const GlobalSettings& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  GlobalSettings* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.lightthemewallpaper_){nullptr}
+    , decltype(_impl_.darkthemewallpaper_){nullptr}
+    , decltype(_impl_.autodownloadwifi_){nullptr}
+    , decltype(_impl_.autodownloadcellular_){nullptr}
+    , decltype(_impl_.autodownloadroaming_){nullptr}
+    , decltype(_impl_.mediavisibility_){}
+    , decltype(_impl_.showindividualnotificationspreview_){}
+    , decltype(_impl_.showgroupnotificationspreview_){}
+    , decltype(_impl_.disappearingmodetimestamp_){}
+    , decltype(_impl_.disappearingmodeduration_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_lightthemewallpaper()) {
+    _this->_impl_.lightthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.lightthemewallpaper_);
+  }
+  if (from._internal_has_darkthemewallpaper()) {
+    _this->_impl_.darkthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.darkthemewallpaper_);
+  }
+  if (from._internal_has_autodownloadwifi()) {
+    _this->_impl_.autodownloadwifi_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadwifi_);
+  }
+  if (from._internal_has_autodownloadcellular()) {
+    _this->_impl_.autodownloadcellular_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadcellular_);
+  }
+  if (from._internal_has_autodownloadroaming()) {
+    _this->_impl_.autodownloadroaming_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadroaming_);
+  }
+  ::memcpy(&_impl_.mediavisibility_, &from._impl_.mediavisibility_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.disappearingmodeduration_) -
+    reinterpret_cast<char*>(&_impl_.mediavisibility_)) + sizeof(_impl_.disappearingmodeduration_));
+  // @@protoc_insertion_point(copy_constructor:proto.GlobalSettings)
+}
+
+inline void GlobalSettings::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.lightthemewallpaper_){nullptr}
+    , decltype(_impl_.darkthemewallpaper_){nullptr}
+    , decltype(_impl_.autodownloadwifi_){nullptr}
+    , decltype(_impl_.autodownloadcellular_){nullptr}
+    , decltype(_impl_.autodownloadroaming_){nullptr}
+    , decltype(_impl_.mediavisibility_){0}
+    , decltype(_impl_.showindividualnotificationspreview_){false}
+    , decltype(_impl_.showgroupnotificationspreview_){false}
+    , decltype(_impl_.disappearingmodetimestamp_){int64_t{0}}
+    , decltype(_impl_.disappearingmodeduration_){0}
+  };
+}
+
+GlobalSettings::~GlobalSettings() {
+  // @@protoc_insertion_point(destructor:proto.GlobalSettings)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void GlobalSettings::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.lightthemewallpaper_;
+  if (this != internal_default_instance()) delete _impl_.darkthemewallpaper_;
+  if (this != internal_default_instance()) delete _impl_.autodownloadwifi_;
+  if (this != internal_default_instance()) delete _impl_.autodownloadcellular_;
+  if (this != internal_default_instance()) delete _impl_.autodownloadroaming_;
+}
+
+void GlobalSettings::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void GlobalSettings::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.GlobalSettings)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.lightthemewallpaper_ != nullptr);
+      _impl_.lightthemewallpaper_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.darkthemewallpaper_ != nullptr);
+      _impl_.darkthemewallpaper_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.autodownloadwifi_ != nullptr);
+      _impl_.autodownloadwifi_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.autodownloadcellular_ != nullptr);
+      _impl_.autodownloadcellular_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.autodownloadroaming_ != nullptr);
+      _impl_.autodownloadroaming_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    ::memset(&_impl_.mediavisibility_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.showgroupnotificationspreview_) -
+        reinterpret_cast<char*>(&_impl_.mediavisibility_)) + sizeof(_impl_.showgroupnotificationspreview_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.disappearingmodetimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.disappearingmodeduration_) -
+        reinterpret_cast<char*>(&_impl_.disappearingmodetimestamp_)) + sizeof(_impl_.disappearingmodeduration_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* GlobalSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.WallpaperSettings lightThemeWallpaper = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_lightthemewallpaper(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaVisibility mediaVisibility = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) {
+            _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WallpaperSettings darkThemeWallpaper = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_darkthemewallpaper(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_autodownloadwifi(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_autodownloadcellular(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_autodownloadroaming(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool showIndividualNotificationsPreview = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_showindividualnotificationspreview(&has_bits);
+          _impl_.showindividualnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool showGroupNotificationsPreview = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_showgroupnotificationspreview(&has_bits);
+          _impl_.showgroupnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 disappearingModeDuration = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_disappearingmodeduration(&has_bits);
+          _impl_.disappearingmodeduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 disappearingModeTimestamp = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_disappearingmodetimestamp(&has_bits);
+          _impl_.disappearingmodetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* GlobalSettings::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.GlobalSettings)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.WallpaperSettings lightThemeWallpaper = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::lightthemewallpaper(this),
+        _Internal::lightthemewallpaper(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MediaVisibility mediaVisibility = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_mediavisibility(), target);
+  }
+
+  // optional .proto.WallpaperSettings darkThemeWallpaper = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::darkthemewallpaper(this),
+        _Internal::darkthemewallpaper(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::autodownloadwifi(this),
+        _Internal::autodownloadwifi(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::autodownloadcellular(this),
+        _Internal::autodownloadcellular(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::autodownloadroaming(this),
+        _Internal::autodownloadroaming(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool showIndividualNotificationsPreview = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_showindividualnotificationspreview(), target);
+  }
+
+  // optional bool showGroupNotificationsPreview = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_showgroupnotificationspreview(), target);
+  }
+
+  // optional int32 disappearingModeDuration = 9;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_disappearingmodeduration(), target);
+  }
+
+  // optional int64 disappearingModeTimestamp = 10;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_disappearingmodetimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.GlobalSettings)
+  return target;
+}
+
+size_t GlobalSettings::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.GlobalSettings)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.WallpaperSettings lightThemeWallpaper = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.lightthemewallpaper_);
+    }
+
+    // optional .proto.WallpaperSettings darkThemeWallpaper = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.darkthemewallpaper_);
+    }
+
+    // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.autodownloadwifi_);
+    }
+
+    // optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.autodownloadcellular_);
+    }
+
+    // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.autodownloadroaming_);
+    }
+
+    // optional .proto.MediaVisibility mediaVisibility = 2;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility());
+    }
+
+    // optional bool showIndividualNotificationsPreview = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool showGroupNotificationsPreview = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional int64 disappearingModeTimestamp = 10;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_disappearingmodetimestamp());
+    }
+
+    // optional int32 disappearingModeDuration = 9;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_disappearingmodeduration());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GlobalSettings::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    GlobalSettings::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GlobalSettings::GetClassData() const { return &_class_data_; }
+
+
+void GlobalSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<GlobalSettings*>(&to_msg);
+  auto& from = static_cast<const GlobalSettings&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.GlobalSettings)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_lightthemewallpaper()->::proto::WallpaperSettings::MergeFrom(
+          from._internal_lightthemewallpaper());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_darkthemewallpaper()->::proto::WallpaperSettings::MergeFrom(
+          from._internal_darkthemewallpaper());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_autodownloadwifi()->::proto::AutoDownloadSettings::MergeFrom(
+          from._internal_autodownloadwifi());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_autodownloadcellular()->::proto::AutoDownloadSettings::MergeFrom(
+          from._internal_autodownloadcellular());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_autodownloadroaming()->::proto::AutoDownloadSettings::MergeFrom(
+          from._internal_autodownloadroaming());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.showindividualnotificationspreview_ = from._impl_.showindividualnotificationspreview_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.showgroupnotificationspreview_ = from._impl_.showgroupnotificationspreview_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.disappearingmodetimestamp_ = from._impl_.disappearingmodetimestamp_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.disappearingmodeduration_ = from._impl_.disappearingmodeduration_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void GlobalSettings::CopyFrom(const GlobalSettings& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.GlobalSettings)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GlobalSettings::IsInitialized() const {
+  return true;
+}
+
+void GlobalSettings::InternalSwap(GlobalSettings* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.disappearingmodeduration_)
+      + sizeof(GlobalSettings::_impl_.disappearingmodeduration_)
+      - PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.lightthemewallpaper_)>(
+          reinterpret_cast<char*>(&_impl_.lightthemewallpaper_),
+          reinterpret_cast<char*>(&other->_impl_.lightthemewallpaper_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata GlobalSettings::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[33]);
+}
+
+// ===================================================================
+
+class GroupParticipant::_Internal {
+ public:
+  using HasBits = decltype(std::declval<GroupParticipant>()._impl_._has_bits_);
+  static void set_has_userjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_rank(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+GroupParticipant::GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.GroupParticipant)
+}
+GroupParticipant::GroupParticipant(const GroupParticipant& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  GroupParticipant* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.rank_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_userjid()) {
+    _this->_impl_.userjid_.Set(from._internal_userjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.rank_ = from._impl_.rank_;
+  // @@protoc_insertion_point(copy_constructor:proto.GroupParticipant)
+}
+
+inline void GroupParticipant::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.rank_){0}
+  };
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+GroupParticipant::~GroupParticipant() {
+  // @@protoc_insertion_point(destructor:proto.GroupParticipant)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void GroupParticipant::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.userjid_.Destroy();
+}
+
+void GroupParticipant::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void GroupParticipant::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.GroupParticipant)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.userjid_.ClearNonDefaultToEmpty();
+  }
+  _impl_.rank_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* GroupParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string userJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_userjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.GroupParticipant.userJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.GroupParticipant.Rank rank = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::GroupParticipant_Rank_IsValid(val))) {
+            _internal_set_rank(static_cast<::proto::GroupParticipant_Rank>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* GroupParticipant::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.GroupParticipant)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string userJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_userjid().data(), static_cast<int>(this->_internal_userjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.GroupParticipant.userJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_userjid(), target);
+  }
+
+  // optional .proto.GroupParticipant.Rank rank = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_rank(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.GroupParticipant)
+  return target;
+}
+
+size_t GroupParticipant::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.GroupParticipant)
+  size_t total_size = 0;
+
+  // required string userJid = 1;
+  if (_internal_has_userjid()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userjid());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.GroupParticipant.Rank rank = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000002u) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_rank());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GroupParticipant::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    GroupParticipant::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GroupParticipant::GetClassData() const { return &_class_data_; }
+
+
+void GroupParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<GroupParticipant*>(&to_msg);
+  auto& from = static_cast<const GroupParticipant&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.GroupParticipant)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_userjid(from._internal_userjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.rank_ = from._impl_.rank_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void GroupParticipant::CopyFrom(const GroupParticipant& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.GroupParticipant)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GroupParticipant::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void GroupParticipant::InternalSwap(GroupParticipant* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.userjid_, lhs_arena,
+      &other->_impl_.userjid_, rhs_arena
+  );
+  swap(_impl_.rank_, other->_impl_.rank_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata GroupParticipant::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[34]);
+}
+
+// ===================================================================
+
+class HandshakeMessage_ClientFinish::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HandshakeMessage_ClientFinish>()._impl_._has_bits_);
+  static void set_has_static_(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_payload(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientFinish)
+}
+HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HandshakeMessage_ClientFinish* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_static_()) {
+    _this->_impl_.static__.Set(from._internal_static_(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_payload()) {
+    _this->_impl_.payload_.Set(from._internal_payload(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientFinish)
+}
+
+inline void HandshakeMessage_ClientFinish::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}
+  };
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HandshakeMessage_ClientFinish::~HandshakeMessage_ClientFinish() {
+  // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientFinish)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HandshakeMessage_ClientFinish::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.static__.Destroy();
+  _impl_.payload_.Destroy();
+}
+
+void HandshakeMessage_ClientFinish::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HandshakeMessage_ClientFinish::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientFinish)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.static__.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.payload_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HandshakeMessage_ClientFinish::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes static = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_static_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes payload = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_payload();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HandshakeMessage_ClientFinish::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientFinish)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes static = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_static_(), target);
+  }
+
+  // optional bytes payload = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_payload(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HandshakeMessage.ClientFinish)
+  return target;
+}
+
+size_t HandshakeMessage_ClientFinish::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientFinish)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes static = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_static_());
+    }
+
+    // optional bytes payload = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_payload());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientFinish::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HandshakeMessage_ClientFinish::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientFinish::GetClassData() const { return &_class_data_; }
+
+
+void HandshakeMessage_ClientFinish::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HandshakeMessage_ClientFinish*>(&to_msg);
+  auto& from = static_cast<const HandshakeMessage_ClientFinish&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientFinish)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_static_(from._internal_static_());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_payload(from._internal_payload());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HandshakeMessage_ClientFinish::CopyFrom(const HandshakeMessage_ClientFinish& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientFinish)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HandshakeMessage_ClientFinish::IsInitialized() const {
+  return true;
+}
+
+void HandshakeMessage_ClientFinish::InternalSwap(HandshakeMessage_ClientFinish* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.static__, lhs_arena,
+      &other->_impl_.static__, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.payload_, lhs_arena,
+      &other->_impl_.payload_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientFinish::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[35]);
+}
+
+// ===================================================================
+
+class HandshakeMessage_ClientHello::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HandshakeMessage_ClientHello>()._impl_._has_bits_);
+  static void set_has_ephemeral(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_static_(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_payload(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientHello)
+}
+HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HandshakeMessage_ClientHello* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ephemeral_){}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.ephemeral_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ephemeral()) {
+    _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_static_()) {
+    _this->_impl_.static__.Set(from._internal_static_(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_payload()) {
+    _this->_impl_.payload_.Set(from._internal_payload(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientHello)
+}
+
+inline void HandshakeMessage_ClientHello::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ephemeral_){}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}
+  };
+  _impl_.ephemeral_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HandshakeMessage_ClientHello::~HandshakeMessage_ClientHello() {
+  // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientHello)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HandshakeMessage_ClientHello::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.ephemeral_.Destroy();
+  _impl_.static__.Destroy();
+  _impl_.payload_.Destroy();
+}
+
+void HandshakeMessage_ClientHello::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HandshakeMessage_ClientHello::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientHello)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.ephemeral_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.static__.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.payload_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HandshakeMessage_ClientHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes ephemeral = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_ephemeral();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes static = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_static_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes payload = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_payload();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HandshakeMessage_ClientHello::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientHello)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes ephemeral = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_ephemeral(), target);
+  }
+
+  // optional bytes static = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_static_(), target);
+  }
+
+  // optional bytes payload = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_payload(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HandshakeMessage.ClientHello)
+  return target;
+}
+
+size_t HandshakeMessage_ClientHello::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientHello)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes ephemeral = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_ephemeral());
+    }
+
+    // optional bytes static = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_static_());
+    }
+
+    // optional bytes payload = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_payload());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientHello::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HandshakeMessage_ClientHello::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientHello::GetClassData() const { return &_class_data_; }
+
+
+void HandshakeMessage_ClientHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HandshakeMessage_ClientHello*>(&to_msg);
+  auto& from = static_cast<const HandshakeMessage_ClientHello&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientHello)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_ephemeral(from._internal_ephemeral());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_static_(from._internal_static_());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_payload(from._internal_payload());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HandshakeMessage_ClientHello::CopyFrom(const HandshakeMessage_ClientHello& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientHello)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HandshakeMessage_ClientHello::IsInitialized() const {
+  return true;
+}
+
+void HandshakeMessage_ClientHello::InternalSwap(HandshakeMessage_ClientHello* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ephemeral_, lhs_arena,
+      &other->_impl_.ephemeral_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.static__, lhs_arena,
+      &other->_impl_.static__, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.payload_, lhs_arena,
+      &other->_impl_.payload_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientHello::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[36]);
+}
+
+// ===================================================================
+
+class HandshakeMessage_ServerHello::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HandshakeMessage_ServerHello>()._impl_._has_bits_);
+  static void set_has_ephemeral(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_static_(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_payload(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ServerHello)
+}
+HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HandshakeMessage_ServerHello* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ephemeral_){}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.ephemeral_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ephemeral()) {
+    _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_static_()) {
+    _this->_impl_.static__.Set(from._internal_static_(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_payload()) {
+    _this->_impl_.payload_.Set(from._internal_payload(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ServerHello)
+}
+
+inline void HandshakeMessage_ServerHello::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ephemeral_){}
+    , decltype(_impl_.static__){}
+    , decltype(_impl_.payload_){}
+  };
+  _impl_.ephemeral_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.static__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.static__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.payload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HandshakeMessage_ServerHello::~HandshakeMessage_ServerHello() {
+  // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ServerHello)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HandshakeMessage_ServerHello::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.ephemeral_.Destroy();
+  _impl_.static__.Destroy();
+  _impl_.payload_.Destroy();
+}
+
+void HandshakeMessage_ServerHello::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HandshakeMessage_ServerHello::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ServerHello)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.ephemeral_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.static__.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.payload_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HandshakeMessage_ServerHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes ephemeral = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_ephemeral();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes static = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_static_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes payload = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_payload();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HandshakeMessage_ServerHello::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ServerHello)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes ephemeral = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_ephemeral(), target);
+  }
+
+  // optional bytes static = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_static_(), target);
+  }
+
+  // optional bytes payload = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_payload(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HandshakeMessage.ServerHello)
+  return target;
+}
+
+size_t HandshakeMessage_ServerHello::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ServerHello)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes ephemeral = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_ephemeral());
+    }
+
+    // optional bytes static = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_static_());
+    }
+
+    // optional bytes payload = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_payload());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ServerHello::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HandshakeMessage_ServerHello::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ServerHello::GetClassData() const { return &_class_data_; }
+
+
+void HandshakeMessage_ServerHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HandshakeMessage_ServerHello*>(&to_msg);
+  auto& from = static_cast<const HandshakeMessage_ServerHello&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ServerHello)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_ephemeral(from._internal_ephemeral());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_static_(from._internal_static_());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_payload(from._internal_payload());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HandshakeMessage_ServerHello::CopyFrom(const HandshakeMessage_ServerHello& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ServerHello)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HandshakeMessage_ServerHello::IsInitialized() const {
+  return true;
+}
+
+void HandshakeMessage_ServerHello::InternalSwap(HandshakeMessage_ServerHello* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ephemeral_, lhs_arena,
+      &other->_impl_.ephemeral_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.static__, lhs_arena,
+      &other->_impl_.static__, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.payload_, lhs_arena,
+      &other->_impl_.payload_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ServerHello::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[37]);
+}
+
+// ===================================================================
+
+class HandshakeMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HandshakeMessage>()._impl_._has_bits_);
+  static const ::proto::HandshakeMessage_ClientHello& clienthello(const HandshakeMessage* msg);
+  static void set_has_clienthello(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::HandshakeMessage_ServerHello& serverhello(const HandshakeMessage* msg);
+  static void set_has_serverhello(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::HandshakeMessage_ClientFinish& clientfinish(const HandshakeMessage* msg);
+  static void set_has_clientfinish(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::HandshakeMessage_ClientHello&
+HandshakeMessage::_Internal::clienthello(const HandshakeMessage* msg) {
+  return *msg->_impl_.clienthello_;
+}
+const ::proto::HandshakeMessage_ServerHello&
+HandshakeMessage::_Internal::serverhello(const HandshakeMessage* msg) {
+  return *msg->_impl_.serverhello_;
+}
+const ::proto::HandshakeMessage_ClientFinish&
+HandshakeMessage::_Internal::clientfinish(const HandshakeMessage* msg) {
+  return *msg->_impl_.clientfinish_;
+}
+HandshakeMessage::HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage)
+}
+HandshakeMessage::HandshakeMessage(const HandshakeMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HandshakeMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.clienthello_){nullptr}
+    , decltype(_impl_.serverhello_){nullptr}
+    , decltype(_impl_.clientfinish_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_clienthello()) {
+    _this->_impl_.clienthello_ = new ::proto::HandshakeMessage_ClientHello(*from._impl_.clienthello_);
+  }
+  if (from._internal_has_serverhello()) {
+    _this->_impl_.serverhello_ = new ::proto::HandshakeMessage_ServerHello(*from._impl_.serverhello_);
+  }
+  if (from._internal_has_clientfinish()) {
+    _this->_impl_.clientfinish_ = new ::proto::HandshakeMessage_ClientFinish(*from._impl_.clientfinish_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage)
+}
+
+inline void HandshakeMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.clienthello_){nullptr}
+    , decltype(_impl_.serverhello_){nullptr}
+    , decltype(_impl_.clientfinish_){nullptr}
+  };
+}
+
+HandshakeMessage::~HandshakeMessage() {
+  // @@protoc_insertion_point(destructor:proto.HandshakeMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HandshakeMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.clienthello_;
+  if (this != internal_default_instance()) delete _impl_.serverhello_;
+  if (this != internal_default_instance()) delete _impl_.clientfinish_;
+}
+
+void HandshakeMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HandshakeMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.clienthello_ != nullptr);
+      _impl_.clienthello_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.serverhello_ != nullptr);
+      _impl_.serverhello_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.clientfinish_ != nullptr);
+      _impl_.clientfinish_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HandshakeMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.HandshakeMessage.ClientHello clientHello = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_clienthello(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.HandshakeMessage.ServerHello serverHello = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_serverhello(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_clientfinish(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HandshakeMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.HandshakeMessage.ClientHello clientHello = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::clienthello(this),
+        _Internal::clienthello(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.HandshakeMessage.ServerHello serverHello = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::serverhello(this),
+        _Internal::serverhello(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::clientfinish(this),
+        _Internal::clientfinish(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HandshakeMessage)
+  return target;
+}
+
+size_t HandshakeMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.HandshakeMessage.ClientHello clientHello = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.clienthello_);
+    }
+
+    // optional .proto.HandshakeMessage.ServerHello serverHello = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.serverhello_);
+    }
+
+    // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.clientfinish_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HandshakeMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage::GetClassData() const { return &_class_data_; }
+
+
+void HandshakeMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HandshakeMessage*>(&to_msg);
+  auto& from = static_cast<const HandshakeMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_clienthello()->::proto::HandshakeMessage_ClientHello::MergeFrom(
+          from._internal_clienthello());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_serverhello()->::proto::HandshakeMessage_ServerHello::MergeFrom(
+          from._internal_serverhello());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_clientfinish()->::proto::HandshakeMessage_ClientFinish::MergeFrom(
+          from._internal_clientfinish());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HandshakeMessage::CopyFrom(const HandshakeMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HandshakeMessage::IsInitialized() const {
+  return true;
+}
+
+void HandshakeMessage::InternalSwap(HandshakeMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clientfinish_)
+      + sizeof(HandshakeMessage::_impl_.clientfinish_)
+      - PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clienthello_)>(
+          reinterpret_cast<char*>(&_impl_.clienthello_),
+          reinterpret_cast<char*>(&other->_impl_.clienthello_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[38]);
+}
+
+// ===================================================================
+
+class HistorySync::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HistorySync>()._impl_._has_bits_);
+  static void set_has_synctype(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_chunkorder(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_progress(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::GlobalSettings& globalsettings(const HistorySync* msg);
+  static void set_has_globalsettings(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_threadidusersecret(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_threaddstimeframeoffset(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0;
+  }
+};
+
+const ::proto::GlobalSettings&
+HistorySync::_Internal::globalsettings(const HistorySync* msg) {
+  return *msg->_impl_.globalsettings_;
+}
+HistorySync::HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HistorySync)
+}
+HistorySync::HistorySync(const HistorySync& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HistorySync* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.conversations_){from._impl_.conversations_}
+    , decltype(_impl_.statusv3messages_){from._impl_.statusv3messages_}
+    , decltype(_impl_.pushnames_){from._impl_.pushnames_}
+    , decltype(_impl_.recentstickers_){from._impl_.recentstickers_}
+    , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_}
+    , decltype(_impl_.threadidusersecret_){}
+    , decltype(_impl_.globalsettings_){nullptr}
+    , decltype(_impl_.synctype_){}
+    , decltype(_impl_.chunkorder_){}
+    , decltype(_impl_.progress_){}
+    , decltype(_impl_.threaddstimeframeoffset_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.threadidusersecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_threadidusersecret()) {
+    _this->_impl_.threadidusersecret_.Set(from._internal_threadidusersecret(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_globalsettings()) {
+    _this->_impl_.globalsettings_ = new ::proto::GlobalSettings(*from._impl_.globalsettings_);
+  }
+  ::memcpy(&_impl_.synctype_, &from._impl_.synctype_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.threaddstimeframeoffset_) -
+    reinterpret_cast<char*>(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_));
+  // @@protoc_insertion_point(copy_constructor:proto.HistorySync)
+}
+
+inline void HistorySync::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.conversations_){arena}
+    , decltype(_impl_.statusv3messages_){arena}
+    , decltype(_impl_.pushnames_){arena}
+    , decltype(_impl_.recentstickers_){arena}
+    , decltype(_impl_.pastparticipants_){arena}
+    , decltype(_impl_.threadidusersecret_){}
+    , decltype(_impl_.globalsettings_){nullptr}
+    , decltype(_impl_.synctype_){0}
+    , decltype(_impl_.chunkorder_){0u}
+    , decltype(_impl_.progress_){0u}
+    , decltype(_impl_.threaddstimeframeoffset_){0u}
+  };
+  _impl_.threadidusersecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HistorySync::~HistorySync() {
+  // @@protoc_insertion_point(destructor:proto.HistorySync)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HistorySync::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.conversations_.~RepeatedPtrField();
+  _impl_.statusv3messages_.~RepeatedPtrField();
+  _impl_.pushnames_.~RepeatedPtrField();
+  _impl_.recentstickers_.~RepeatedPtrField();
+  _impl_.pastparticipants_.~RepeatedPtrField();
+  _impl_.threadidusersecret_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.globalsettings_;
+}
+
+void HistorySync::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HistorySync::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HistorySync)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.conversations_.Clear();
+  _impl_.statusv3messages_.Clear();
+  _impl_.pushnames_.Clear();
+  _impl_.recentstickers_.Clear();
+  _impl_.pastparticipants_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.threadidusersecret_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.globalsettings_ != nullptr);
+      _impl_.globalsettings_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000003cu) {
+    ::memset(&_impl_.synctype_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.threaddstimeframeoffset_) -
+        reinterpret_cast<char*>(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HistorySync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required .proto.HistorySync.HistorySyncType syncType = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::HistorySync_HistorySyncType_IsValid(val))) {
+            _internal_set_synctype(static_cast<::proto::HistorySync_HistorySyncType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Conversation conversations = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_conversations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.WebMessageInfo statusV3Messages = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_statusv3messages(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 chunkOrder = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_chunkorder(&has_bits);
+          _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 progress = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_progress(&has_bits);
+          _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Pushname pushnames = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_pushnames(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.GlobalSettings globalSettings = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_globalsettings(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes threadIdUserSecret = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_threadidusersecret();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 threadDsTimeframeOffset = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_threaddstimeframeoffset(&has_bits);
+          _impl_.threaddstimeframeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.StickerMetadata recentStickers = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_recentstickers(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.PastParticipants pastParticipants = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HistorySync::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySync)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required .proto.HistorySync.HistorySyncType syncType = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_synctype(), target);
+  }
+
+  // repeated .proto.Conversation conversations = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_conversations_size()); i < n; i++) {
+    const auto& repfield = this->_internal_conversations(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.WebMessageInfo statusV3Messages = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_statusv3messages_size()); i < n; i++) {
+    const auto& repfield = this->_internal_statusv3messages(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 chunkOrder = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_chunkorder(), target);
+  }
+
+  // optional uint32 progress = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_progress(), target);
+  }
+
+  // repeated .proto.Pushname pushnames = 7;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_pushnames_size()); i < n; i++) {
+    const auto& repfield = this->_internal_pushnames(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.GlobalSettings globalSettings = 8;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::globalsettings(this),
+        _Internal::globalsettings(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes threadIdUserSecret = 9;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        9, this->_internal_threadidusersecret(), target);
+  }
+
+  // optional uint32 threadDsTimeframeOffset = 10;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_threaddstimeframeoffset(), target);
+  }
+
+  // repeated .proto.StickerMetadata recentStickers = 11;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_recentstickers_size()); i < n; i++) {
+    const auto& repfield = this->_internal_recentstickers(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.PastParticipants pastParticipants = 12;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_pastparticipants_size()); i < n; i++) {
+    const auto& repfield = this->_internal_pastparticipants(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HistorySync)
+  return target;
+}
+
+size_t HistorySync::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HistorySync)
+  size_t total_size = 0;
+
+  // required .proto.HistorySync.HistorySyncType syncType = 1;
+  if (_internal_has_synctype()) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Conversation conversations = 2;
+  total_size += 1UL * this->_internal_conversations_size();
+  for (const auto& msg : this->_impl_.conversations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.WebMessageInfo statusV3Messages = 3;
+  total_size += 1UL * this->_internal_statusv3messages_size();
+  for (const auto& msg : this->_impl_.statusv3messages_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.Pushname pushnames = 7;
+  total_size += 1UL * this->_internal_pushnames_size();
+  for (const auto& msg : this->_impl_.pushnames_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.StickerMetadata recentStickers = 11;
+  total_size += 1UL * this->_internal_recentstickers_size();
+  for (const auto& msg : this->_impl_.recentstickers_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.PastParticipants pastParticipants = 12;
+  total_size += 1UL * this->_internal_pastparticipants_size();
+  for (const auto& msg : this->_impl_.pastparticipants_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes threadIdUserSecret = 9;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_threadidusersecret());
+    }
+
+    // optional .proto.GlobalSettings globalSettings = 8;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.globalsettings_);
+    }
+
+  }
+  if (cached_has_bits & 0x00000038u) {
+    // optional uint32 chunkOrder = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder());
+    }
+
+    // optional uint32 progress = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress());
+    }
+
+    // optional uint32 threadDsTimeframeOffset = 10;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_threaddstimeframeoffset());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySync::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HistorySync::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySync::GetClassData() const { return &_class_data_; }
+
+
+void HistorySync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HistorySync*>(&to_msg);
+  auto& from = static_cast<const HistorySync&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySync)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.conversations_.MergeFrom(from._impl_.conversations_);
+  _this->_impl_.statusv3messages_.MergeFrom(from._impl_.statusv3messages_);
+  _this->_impl_.pushnames_.MergeFrom(from._impl_.pushnames_);
+  _this->_impl_.recentstickers_.MergeFrom(from._impl_.recentstickers_);
+  _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_threadidusersecret(from._internal_threadidusersecret());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_globalsettings()->::proto::GlobalSettings::MergeFrom(
+          from._internal_globalsettings());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.synctype_ = from._impl_.synctype_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.chunkorder_ = from._impl_.chunkorder_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.progress_ = from._impl_.progress_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.threaddstimeframeoffset_ = from._impl_.threaddstimeframeoffset_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HistorySync::CopyFrom(const HistorySync& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySync)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HistorySync::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.conversations_))
+    return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.statusv3messages_))
+    return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_))
+    return false;
+  return true;
+}
+
+void HistorySync::InternalSwap(HistorySync* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.conversations_.InternalSwap(&other->_impl_.conversations_);
+  _impl_.statusv3messages_.InternalSwap(&other->_impl_.statusv3messages_);
+  _impl_.pushnames_.InternalSwap(&other->_impl_.pushnames_);
+  _impl_.recentstickers_.InternalSwap(&other->_impl_.recentstickers_);
+  _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.threadidusersecret_, lhs_arena,
+      &other->_impl_.threadidusersecret_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.threaddstimeframeoffset_)
+      + sizeof(HistorySync::_impl_.threaddstimeframeoffset_)
+      - PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.globalsettings_)>(
+          reinterpret_cast<char*>(&_impl_.globalsettings_),
+          reinterpret_cast<char*>(&other->_impl_.globalsettings_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HistorySync::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[39]);
+}
+
+// ===================================================================
+
+class HistorySyncMsg::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HistorySyncMsg>()._impl_._has_bits_);
+  static const ::proto::WebMessageInfo& message(const HistorySyncMsg* msg);
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_msgorderid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::WebMessageInfo&
+HistorySyncMsg::_Internal::message(const HistorySyncMsg* msg) {
+  return *msg->_impl_.message_;
+}
+HistorySyncMsg::HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HistorySyncMsg)
+}
+HistorySyncMsg::HistorySyncMsg(const HistorySyncMsg& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HistorySyncMsg* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.msgorderid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_message()) {
+    _this->_impl_.message_ = new ::proto::WebMessageInfo(*from._impl_.message_);
+  }
+  _this->_impl_.msgorderid_ = from._impl_.msgorderid_;
+  // @@protoc_insertion_point(copy_constructor:proto.HistorySyncMsg)
+}
+
+inline void HistorySyncMsg::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.msgorderid_){uint64_t{0u}}
+  };
+}
+
+HistorySyncMsg::~HistorySyncMsg() {
+  // @@protoc_insertion_point(destructor:proto.HistorySyncMsg)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HistorySyncMsg::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.message_;
+}
+
+void HistorySyncMsg::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HistorySyncMsg::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HistorySyncMsg)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.message_ != nullptr);
+    _impl_.message_->Clear();
+  }
+  _impl_.msgorderid_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HistorySyncMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.WebMessageInfo message = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_message(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 msgOrderId = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_msgorderid(&has_bits);
+          _impl_.msgorderid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HistorySyncMsg::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySyncMsg)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.WebMessageInfo message = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::message(this),
+        _Internal::message(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint64 msgOrderId = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_msgorderid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HistorySyncMsg)
+  return target;
+}
+
+size_t HistorySyncMsg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HistorySyncMsg)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.WebMessageInfo message = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.message_);
+    }
+
+    // optional uint64 msgOrderId = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_msgorderid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySyncMsg::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HistorySyncMsg::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySyncMsg::GetClassData() const { return &_class_data_; }
+
+
+void HistorySyncMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HistorySyncMsg*>(&to_msg);
+  auto& from = static_cast<const HistorySyncMsg&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySyncMsg)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_message()->::proto::WebMessageInfo::MergeFrom(
+          from._internal_message());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.msgorderid_ = from._impl_.msgorderid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HistorySyncMsg::CopyFrom(const HistorySyncMsg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySyncMsg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HistorySyncMsg::IsInitialized() const {
+  if (_internal_has_message()) {
+    if (!_impl_.message_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void HistorySyncMsg::InternalSwap(HistorySyncMsg* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.msgorderid_)
+      + sizeof(HistorySyncMsg::_impl_.msgorderid_)
+      - PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.message_)>(
+          reinterpret_cast<char*>(&_impl_.message_),
+          reinterpret_cast<char*>(&other->_impl_.message_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HistorySyncMsg::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[40]);
+}
+
+// ===================================================================
+
+class HydratedTemplateButton_HydratedCallButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HydratedTemplateButton_HydratedCallButton>()._impl_._has_bits_);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_phonenumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedCallButton)
+}
+HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HydratedTemplateButton_HydratedCallButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.phonenumber_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_.Set(from._internal_displaytext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.phonenumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phonenumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_phonenumber()) {
+    _this->_impl_.phonenumber_.Set(from._internal_phonenumber(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedCallButton)
+}
+
+inline void HydratedTemplateButton_HydratedCallButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.phonenumber_){}
+  };
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.phonenumber_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phonenumber_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HydratedTemplateButton_HydratedCallButton::~HydratedTemplateButton_HydratedCallButton() {
+  // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedCallButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HydratedTemplateButton_HydratedCallButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displaytext_.Destroy();
+  _impl_.phonenumber_.Destroy();
+}
+
+void HydratedTemplateButton_HydratedCallButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HydratedTemplateButton_HydratedCallButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedCallButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displaytext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.phonenumber_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HydratedTemplateButton_HydratedCallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.displayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string phoneNumber = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_phonenumber();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HydratedTemplateButton_HydratedCallButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedCallButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displaytext().data(), static_cast<int>(this->_internal_displaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedCallButton.displayText");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displaytext(), target);
+  }
+
+  // optional string phoneNumber = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_phonenumber().data(), static_cast<int>(this->_internal_phonenumber().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_phonenumber(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HydratedTemplateButton.HydratedCallButton)
+  return target;
+}
+
+size_t HydratedTemplateButton_HydratedCallButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedCallButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string displayText = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displaytext());
+    }
+
+    // optional string phoneNumber = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_phonenumber());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedCallButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HydratedTemplateButton_HydratedCallButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedCallButton::GetClassData() const { return &_class_data_; }
+
+
+void HydratedTemplateButton_HydratedCallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HydratedTemplateButton_HydratedCallButton*>(&to_msg);
+  auto& from = static_cast<const HydratedTemplateButton_HydratedCallButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedCallButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displaytext(from._internal_displaytext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_phonenumber(from._internal_phonenumber());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HydratedTemplateButton_HydratedCallButton::CopyFrom(const HydratedTemplateButton_HydratedCallButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedCallButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HydratedTemplateButton_HydratedCallButton::IsInitialized() const {
+  return true;
+}
+
+void HydratedTemplateButton_HydratedCallButton::InternalSwap(HydratedTemplateButton_HydratedCallButton* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displaytext_, lhs_arena,
+      &other->_impl_.displaytext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.phonenumber_, lhs_arena,
+      &other->_impl_.phonenumber_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedCallButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[41]);
+}
+
+// ===================================================================
+
+class HydratedTemplateButton_HydratedQuickReplyButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HydratedTemplateButton_HydratedQuickReplyButton>()._impl_._has_bits_);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+}
+HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HydratedTemplateButton_HydratedQuickReplyButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_.Set(from._internal_displaytext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+}
+
+inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.id_){}
+  };
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HydratedTemplateButton_HydratedQuickReplyButton::~HydratedTemplateButton_HydratedQuickReplyButton() {
+  // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displaytext_.Destroy();
+  _impl_.id_.Destroy();
+}
+
+void HydratedTemplateButton_HydratedQuickReplyButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HydratedTemplateButton_HydratedQuickReplyButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displaytext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HydratedTemplateButton_HydratedQuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HydratedTemplateButton_HydratedQuickReplyButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displaytext().data(), static_cast<int>(this->_internal_displaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displaytext(), target);
+  }
+
+  // optional string id = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedQuickReplyButton.id");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  return target;
+}
+
+size_t HydratedTemplateButton_HydratedQuickReplyButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string displayText = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displaytext());
+    }
+
+    // optional string id = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedQuickReplyButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedQuickReplyButton::GetClassData() const { return &_class_data_; }
+
+
+void HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HydratedTemplateButton_HydratedQuickReplyButton*>(&to_msg);
+  auto& from = static_cast<const HydratedTemplateButton_HydratedQuickReplyButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displaytext(from._internal_displaytext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HydratedTemplateButton_HydratedQuickReplyButton::CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HydratedTemplateButton_HydratedQuickReplyButton::IsInitialized() const {
+  return true;
+}
+
+void HydratedTemplateButton_HydratedQuickReplyButton::InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displaytext_, lhs_arena,
+      &other->_impl_.displaytext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedQuickReplyButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[42]);
+}
+
+// ===================================================================
+
+class HydratedTemplateButton_HydratedURLButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HydratedTemplateButton_HydratedURLButton>()._impl_._has_bits_);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedURLButton)
+}
+HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HydratedTemplateButton_HydratedURLButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.url_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_.Set(from._internal_displaytext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedURLButton)
+}
+
+inline void HydratedTemplateButton_HydratedURLButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+    , decltype(_impl_.url_){}
+  };
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HydratedTemplateButton_HydratedURLButton::~HydratedTemplateButton_HydratedURLButton() {
+  // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedURLButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HydratedTemplateButton_HydratedURLButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displaytext_.Destroy();
+  _impl_.url_.Destroy();
+}
+
+void HydratedTemplateButton_HydratedURLButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HydratedTemplateButton_HydratedURLButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedURLButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displaytext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HydratedTemplateButton_HydratedURLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.displayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HydratedTemplateButton_HydratedURLButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedURLButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displaytext().data(), static_cast<int>(this->_internal_displaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedURLButton.displayText");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displaytext(), target);
+  }
+
+  // optional string url = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.HydratedTemplateButton.HydratedURLButton.url");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HydratedTemplateButton.HydratedURLButton)
+  return target;
+}
+
+size_t HydratedTemplateButton_HydratedURLButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedURLButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string displayText = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displaytext());
+    }
+
+    // optional string url = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedURLButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HydratedTemplateButton_HydratedURLButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedURLButton::GetClassData() const { return &_class_data_; }
+
+
+void HydratedTemplateButton_HydratedURLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HydratedTemplateButton_HydratedURLButton*>(&to_msg);
+  auto& from = static_cast<const HydratedTemplateButton_HydratedURLButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedURLButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displaytext(from._internal_displaytext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HydratedTemplateButton_HydratedURLButton::CopyFrom(const HydratedTemplateButton_HydratedURLButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedURLButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HydratedTemplateButton_HydratedURLButton::IsInitialized() const {
+  return true;
+}
+
+void HydratedTemplateButton_HydratedURLButton::InternalSwap(HydratedTemplateButton_HydratedURLButton* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displaytext_, lhs_arena,
+      &other->_impl_.displaytext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedURLButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[43]);
+}
+
+// ===================================================================
+
+class HydratedTemplateButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HydratedTemplateButton>()._impl_._has_bits_);
+  static void set_has_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton(const HydratedTemplateButton* msg);
+  static const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton(const HydratedTemplateButton* msg);
+  static const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton(const HydratedTemplateButton* msg);
+};
+
+const ::proto::HydratedTemplateButton_HydratedQuickReplyButton&
+HydratedTemplateButton::_Internal::quickreplybutton(const HydratedTemplateButton* msg) {
+  return *msg->_impl_.hydratedButton_.quickreplybutton_;
+}
+const ::proto::HydratedTemplateButton_HydratedURLButton&
+HydratedTemplateButton::_Internal::urlbutton(const HydratedTemplateButton* msg) {
+  return *msg->_impl_.hydratedButton_.urlbutton_;
+}
+const ::proto::HydratedTemplateButton_HydratedCallButton&
+HydratedTemplateButton::_Internal::callbutton(const HydratedTemplateButton* msg) {
+  return *msg->_impl_.hydratedButton_.callbutton_;
+}
+void HydratedTemplateButton::set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_hydratedButton();
+  if (quickreplybutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton);
+    if (message_arena != submessage_arena) {
+      quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quickreplybutton, submessage_arena);
+    }
+    set_has_quickreplybutton();
+    _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.quickReplyButton)
+}
+void HydratedTemplateButton::set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_hydratedButton();
+  if (urlbutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton);
+    if (message_arena != submessage_arena) {
+      urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, urlbutton, submessage_arena);
+    }
+    set_has_urlbutton();
+    _impl_.hydratedButton_.urlbutton_ = urlbutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.urlButton)
+}
+void HydratedTemplateButton::set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_hydratedButton();
+  if (callbutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton);
+    if (message_arena != submessage_arena) {
+      callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, callbutton, submessage_arena);
+    }
+    set_has_callbutton();
+    _impl_.hydratedButton_.callbutton_ = callbutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.callButton)
+}
+HydratedTemplateButton::HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton)
+}
+HydratedTemplateButton::HydratedTemplateButton(const HydratedTemplateButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HydratedTemplateButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){}
+    , decltype(_impl_.hydratedButton_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.index_ = from._impl_.index_;
+  clear_has_hydratedButton();
+  switch (from.hydratedButton_case()) {
+    case kQuickReplyButton: {
+      _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom(
+          from._internal_quickreplybutton());
+      break;
+    }
+    case kUrlButton: {
+      _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom(
+          from._internal_urlbutton());
+      break;
+    }
+    case kCallButton: {
+      _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom(
+          from._internal_callbutton());
+      break;
+    }
+    case HYDRATEDBUTTON_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton)
+}
+
+inline void HydratedTemplateButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){0u}
+    , decltype(_impl_.hydratedButton_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_hydratedButton();
+}
+
+HydratedTemplateButton::~HydratedTemplateButton() {
+  // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HydratedTemplateButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_hydratedButton()) {
+    clear_hydratedButton();
+  }
+}
+
+void HydratedTemplateButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HydratedTemplateButton::clear_hydratedButton() {
+// @@protoc_insertion_point(one_of_clear_start:proto.HydratedTemplateButton)
+  switch (hydratedButton_case()) {
+    case kQuickReplyButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.hydratedButton_.quickreplybutton_;
+      }
+      break;
+    }
+    case kUrlButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.hydratedButton_.urlbutton_;
+      }
+      break;
+    }
+    case kCallButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.hydratedButton_.callbutton_;
+      }
+      break;
+    }
+    case HYDRATEDBUTTON_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET;
+}
+
+
+void HydratedTemplateButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.index_ = 0u;
+  clear_hydratedButton();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* HydratedTemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 index = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_index(&has_bits);
+          _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HydratedTemplateButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (hydratedButton_case()) {
+    case kQuickReplyButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::quickreplybutton(this),
+          _Internal::quickreplybutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kUrlButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::urlbutton(this),
+          _Internal::urlbutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kCallButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::callbutton(this),
+          _Internal::callbutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 index = 4;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.HydratedTemplateButton)
+  return target;
+}
+
+size_t HydratedTemplateButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint32 index = 4;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+  }
+
+  switch (hydratedButton_case()) {
+    // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
+    case kQuickReplyButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.hydratedButton_.quickreplybutton_);
+      break;
+    }
+    // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
+    case kUrlButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.hydratedButton_.urlbutton_);
+      break;
+    }
+    // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
+    case kCallButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.hydratedButton_.callbutton_);
+      break;
+    }
+    case HYDRATEDBUTTON_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HydratedTemplateButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton::GetClassData() const { return &_class_data_; }
+
+
+void HydratedTemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HydratedTemplateButton*>(&to_msg);
+  auto& from = static_cast<const HydratedTemplateButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_index()) {
+    _this->_internal_set_index(from._internal_index());
+  }
+  switch (from.hydratedButton_case()) {
+    case kQuickReplyButton: {
+      _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom(
+          from._internal_quickreplybutton());
+      break;
+    }
+    case kUrlButton: {
+      _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom(
+          from._internal_urlbutton());
+      break;
+    }
+    case kCallButton: {
+      _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom(
+          from._internal_callbutton());
+      break;
+    }
+    case HYDRATEDBUTTON_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void HydratedTemplateButton::CopyFrom(const HydratedTemplateButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HydratedTemplateButton::IsInitialized() const {
+  return true;
+}
+
+void HydratedTemplateButton::InternalSwap(HydratedTemplateButton* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.index_, other->_impl_.index_);
+  swap(_impl_.hydratedButton_, other->_impl_.hydratedButton_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[44]);
+}
+
+// ===================================================================
+
+class IdentityKeyPairStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<IdentityKeyPairStructure>()._impl_._has_bits_);
+  static void set_has_publickey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_privatekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+IdentityKeyPairStructure::IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.IdentityKeyPairStructure)
+}
+IdentityKeyPairStructure::IdentityKeyPairStructure(const IdentityKeyPairStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  IdentityKeyPairStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_publickey()) {
+    _this->_impl_.publickey_.Set(from._internal_publickey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_privatekey()) {
+    _this->_impl_.privatekey_.Set(from._internal_privatekey(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.IdentityKeyPairStructure)
+}
+
+inline void IdentityKeyPairStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}
+  };
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+IdentityKeyPairStructure::~IdentityKeyPairStructure() {
+  // @@protoc_insertion_point(destructor:proto.IdentityKeyPairStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void IdentityKeyPairStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.publickey_.Destroy();
+  _impl_.privatekey_.Destroy();
+}
+
+void IdentityKeyPairStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void IdentityKeyPairStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.IdentityKeyPairStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.publickey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.privatekey_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* IdentityKeyPairStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes publicKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_publickey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes privateKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_privatekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* IdentityKeyPairStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.IdentityKeyPairStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes publicKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_publickey(), target);
+  }
+
+  // optional bytes privateKey = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_privatekey(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.IdentityKeyPairStructure)
+  return target;
+}
+
+size_t IdentityKeyPairStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.IdentityKeyPairStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes publicKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_publickey());
+    }
+
+    // optional bytes privateKey = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_privatekey());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IdentityKeyPairStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    IdentityKeyPairStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IdentityKeyPairStructure::GetClassData() const { return &_class_data_; }
+
+
+void IdentityKeyPairStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<IdentityKeyPairStructure*>(&to_msg);
+  auto& from = static_cast<const IdentityKeyPairStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.IdentityKeyPairStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_publickey(from._internal_publickey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_privatekey(from._internal_privatekey());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void IdentityKeyPairStructure::CopyFrom(const IdentityKeyPairStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.IdentityKeyPairStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool IdentityKeyPairStructure::IsInitialized() const {
+  return true;
+}
+
+void IdentityKeyPairStructure::InternalSwap(IdentityKeyPairStructure* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.publickey_, lhs_arena,
+      &other->_impl_.publickey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.privatekey_, lhs_arena,
+      &other->_impl_.privatekey_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata IdentityKeyPairStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[45]);
+}
+
+// ===================================================================
+
+class InteractiveAnnotation::_Internal {
+ public:
+  static const ::proto::Location& location(const InteractiveAnnotation* msg);
+};
+
+const ::proto::Location&
+InteractiveAnnotation::_Internal::location(const InteractiveAnnotation* msg) {
+  return *msg->_impl_.action_.location_;
+}
+void InteractiveAnnotation::set_allocated_location(::proto::Location* location) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_action();
+  if (location) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(location);
+    if (message_arena != submessage_arena) {
+      location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, location, submessage_arena);
+    }
+    set_has_location();
+    _impl_.action_.location_ = location;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.InteractiveAnnotation.location)
+}
+InteractiveAnnotation::InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.InteractiveAnnotation)
+}
+InteractiveAnnotation::InteractiveAnnotation(const InteractiveAnnotation& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  InteractiveAnnotation* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.polygonvertices_){from._impl_.polygonvertices_}
+    , decltype(_impl_.action_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_action();
+  switch (from.action_case()) {
+    case kLocation: {
+      _this->_internal_mutable_location()->::proto::Location::MergeFrom(
+          from._internal_location());
+      break;
+    }
+    case ACTION_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.InteractiveAnnotation)
+}
+
+inline void InteractiveAnnotation::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.polygonvertices_){arena}
+    , decltype(_impl_.action_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_action();
+}
+
+InteractiveAnnotation::~InteractiveAnnotation() {
+  // @@protoc_insertion_point(destructor:proto.InteractiveAnnotation)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void InteractiveAnnotation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.polygonvertices_.~RepeatedPtrField();
+  if (has_action()) {
+    clear_action();
+  }
+}
+
+void InteractiveAnnotation::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void InteractiveAnnotation::clear_action() {
+// @@protoc_insertion_point(one_of_clear_start:proto.InteractiveAnnotation)
+  switch (action_case()) {
+    case kLocation: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.action_.location_;
+      }
+      break;
+    }
+    case ACTION_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = ACTION_NOT_SET;
+}
+
+
+void InteractiveAnnotation::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.InteractiveAnnotation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.polygonvertices_.Clear();
+  clear_action();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* InteractiveAnnotation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.Point polygonVertices = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_polygonvertices(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Location location = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_location(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* InteractiveAnnotation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.InteractiveAnnotation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.Point polygonVertices = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_polygonvertices_size()); i < n; i++) {
+    const auto& repfield = this->_internal_polygonvertices(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // .proto.Location location = 2;
+  if (_internal_has_location()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::location(this),
+        _Internal::location(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.InteractiveAnnotation)
+  return target;
+}
+
+size_t InteractiveAnnotation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.InteractiveAnnotation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Point polygonVertices = 1;
+  total_size += 1UL * this->_internal_polygonvertices_size();
+  for (const auto& msg : this->_impl_.polygonvertices_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  switch (action_case()) {
+    // .proto.Location location = 2;
+    case kLocation: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.action_.location_);
+      break;
+    }
+    case ACTION_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InteractiveAnnotation::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    InteractiveAnnotation::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InteractiveAnnotation::GetClassData() const { return &_class_data_; }
+
+
+void InteractiveAnnotation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<InteractiveAnnotation*>(&to_msg);
+  auto& from = static_cast<const InteractiveAnnotation&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.InteractiveAnnotation)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.polygonvertices_.MergeFrom(from._impl_.polygonvertices_);
+  switch (from.action_case()) {
+    case kLocation: {
+      _this->_internal_mutable_location()->::proto::Location::MergeFrom(
+          from._internal_location());
+      break;
+    }
+    case ACTION_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void InteractiveAnnotation::CopyFrom(const InteractiveAnnotation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.InteractiveAnnotation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InteractiveAnnotation::IsInitialized() const {
+  return true;
+}
+
+void InteractiveAnnotation::InternalSwap(InteractiveAnnotation* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.polygonvertices_.InternalSwap(&other->_impl_.polygonvertices_);
+  swap(_impl_.action_, other->_impl_.action_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata InteractiveAnnotation::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[46]);
+}
+
+// ===================================================================
+
+class KeepInChat::_Internal {
+ public:
+  using HasBits = decltype(std::declval<KeepInChat>()._impl_._has_bits_);
+  static void set_has_keeptype(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_servertimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::MessageKey& key(const KeepInChat* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_devicejid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::MessageKey&
+KeepInChat::_Internal::key(const KeepInChat* msg) {
+  return *msg->_impl_.key_;
+}
+KeepInChat::KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.KeepInChat)
+}
+KeepInChat::KeepInChat(const KeepInChat& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  KeepInChat* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.devicejid_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.servertimestamp_){}
+    , decltype(_impl_.keeptype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.devicejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.devicejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_devicejid()) {
+    _this->_impl_.devicejid_.Set(from._internal_devicejid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  ::memcpy(&_impl_.servertimestamp_, &from._impl_.servertimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.keeptype_) -
+    reinterpret_cast<char*>(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_));
+  // @@protoc_insertion_point(copy_constructor:proto.KeepInChat)
+}
+
+inline void KeepInChat::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.devicejid_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.servertimestamp_){int64_t{0}}
+    , decltype(_impl_.keeptype_){0}
+  };
+  _impl_.devicejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.devicejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+KeepInChat::~KeepInChat() {
+  // @@protoc_insertion_point(destructor:proto.KeepInChat)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void KeepInChat::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.devicejid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void KeepInChat::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void KeepInChat::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.KeepInChat)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.devicejid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.servertimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.keeptype_) -
+        reinterpret_cast<char*>(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* KeepInChat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.KeepType keepType = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) {
+            _internal_set_keeptype(static_cast<::proto::KeepType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 serverTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_servertimestamp(&has_bits);
+          _impl_.servertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MessageKey key = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string deviceJid = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_devicejid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.KeepInChat.deviceJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* KeepInChat::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.KeepInChat)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.KeepType keepType = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_keeptype(), target);
+  }
+
+  // optional int64 serverTimestamp = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_servertimestamp(), target);
+  }
+
+  // optional .proto.MessageKey key = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string deviceJid = 4;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_devicejid().data(), static_cast<int>(this->_internal_devicejid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.KeepInChat.deviceJid");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_devicejid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.KeepInChat)
+  return target;
+}
+
+size_t KeepInChat::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.KeepInChat)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string deviceJid = 4;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_devicejid());
+    }
+
+    // optional .proto.MessageKey key = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional int64 serverTimestamp = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_servertimestamp());
+    }
+
+    // optional .proto.KeepType keepType = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeepInChat::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    KeepInChat::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeepInChat::GetClassData() const { return &_class_data_; }
+
+
+void KeepInChat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<KeepInChat*>(&to_msg);
+  auto& from = static_cast<const KeepInChat&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeepInChat)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_devicejid(from._internal_devicejid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.servertimestamp_ = from._impl_.servertimestamp_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.keeptype_ = from._impl_.keeptype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void KeepInChat::CopyFrom(const KeepInChat& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeepInChat)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool KeepInChat::IsInitialized() const {
+  return true;
+}
+
+void KeepInChat::InternalSwap(KeepInChat* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.devicejid_, lhs_arena,
+      &other->_impl_.devicejid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.keeptype_)
+      + sizeof(KeepInChat::_impl_.keeptype_)
+      - PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata KeepInChat::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[47]);
+}
+
+// ===================================================================
+
+class KeyId::_Internal {
+ public:
+  using HasBits = decltype(std::declval<KeyId>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+KeyId::KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.KeyId)
+}
+KeyId::KeyId(const KeyId& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  KeyId* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.KeyId)
+}
+
+inline void KeyId::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+KeyId::~KeyId() {
+  // @@protoc_insertion_point(destructor:proto.KeyId)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void KeyId::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+}
+
+void KeyId::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void KeyId::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.KeyId)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.id_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* KeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* KeyId::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.KeyId)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.KeyId)
+  return target;
+}
+
+size_t KeyId::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.KeyId)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes id = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_id());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeyId::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    KeyId::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeyId::GetClassData() const { return &_class_data_; }
+
+
+void KeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<KeyId*>(&to_msg);
+  auto& from = static_cast<const KeyId&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeyId)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_id()) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void KeyId::CopyFrom(const KeyId& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeyId)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool KeyId::IsInitialized() const {
+  return true;
+}
+
+void KeyId::InternalSwap(KeyId* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata KeyId::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[48]);
+}
+
+// ===================================================================
+
+class LocalizedName::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LocalizedName>()._impl_._has_bits_);
+  static void set_has_lg(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_lc(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_verifiedname(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+LocalizedName::LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.LocalizedName)
+}
+LocalizedName::LocalizedName(const LocalizedName& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  LocalizedName* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.lg_){}
+    , decltype(_impl_.lc_){}
+    , decltype(_impl_.verifiedname_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.lg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.lg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_lg()) {
+    _this->_impl_.lg_.Set(from._internal_lg(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.lc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.lc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_lc()) {
+    _this->_impl_.lc_.Set(from._internal_lc(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.verifiedname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_verifiedname()) {
+    _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.LocalizedName)
+}
+
+inline void LocalizedName::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.lg_){}
+    , decltype(_impl_.lc_){}
+    , decltype(_impl_.verifiedname_){}
+  };
+  _impl_.lg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.lg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.lc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.lc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.verifiedname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+LocalizedName::~LocalizedName() {
+  // @@protoc_insertion_point(destructor:proto.LocalizedName)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LocalizedName::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.lg_.Destroy();
+  _impl_.lc_.Destroy();
+  _impl_.verifiedname_.Destroy();
+}
+
+void LocalizedName::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LocalizedName::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.LocalizedName)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.lg_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.lc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.verifiedname_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* LocalizedName::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string lg = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_lg();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lg");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string lc = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_lc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string verifiedName = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_verifiedname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.LocalizedName.verifiedName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LocalizedName::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.LocalizedName)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string lg = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_lg().data(), static_cast<int>(this->_internal_lg().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.LocalizedName.lg");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_lg(), target);
+  }
+
+  // optional string lc = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_lc().data(), static_cast<int>(this->_internal_lc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.LocalizedName.lc");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_lc(), target);
+  }
+
+  // optional string verifiedName = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_verifiedname().data(), static_cast<int>(this->_internal_verifiedname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.LocalizedName.verifiedName");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_verifiedname(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.LocalizedName)
+  return target;
+}
+
+size_t LocalizedName::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.LocalizedName)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string lg = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_lg());
+    }
+
+    // optional string lc = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_lc());
+    }
+
+    // optional string verifiedName = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_verifiedname());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LocalizedName::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    LocalizedName::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LocalizedName::GetClassData() const { return &_class_data_; }
+
+
+void LocalizedName::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<LocalizedName*>(&to_msg);
+  auto& from = static_cast<const LocalizedName&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.LocalizedName)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_lg(from._internal_lg());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_lc(from._internal_lc());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_verifiedname(from._internal_verifiedname());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void LocalizedName::CopyFrom(const LocalizedName& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.LocalizedName)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LocalizedName::IsInitialized() const {
+  return true;
+}
+
+void LocalizedName::InternalSwap(LocalizedName* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.lg_, lhs_arena,
+      &other->_impl_.lg_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.lc_, lhs_arena,
+      &other->_impl_.lc_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.verifiedname_, lhs_arena,
+      &other->_impl_.verifiedname_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata LocalizedName::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[49]);
+}
+
+// ===================================================================
+
+class Location::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Location>()._impl_._has_bits_);
+  static void set_has_degreeslatitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_degreeslongitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Location::Location(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Location)
+}
+Location::Location(const Location& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Location* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.degreeslatitude_){}
+    , decltype(_impl_.degreeslongitude_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.degreeslongitude_) -
+    reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_));
+  // @@protoc_insertion_point(copy_constructor:proto.Location)
+}
+
+inline void Location::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.degreeslatitude_){0}
+    , decltype(_impl_.degreeslongitude_){0}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Location::~Location() {
+  // @@protoc_insertion_point(destructor:proto.Location)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Location::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void Location::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Location::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Location)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.degreeslatitude_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.degreeslongitude_) -
+        reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Location::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional double degreesLatitude = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
+          _Internal::set_has_degreeslatitude(&has_bits);
+          _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double degreesLongitude = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          _Internal::set_has_degreeslongitude(&has_bits);
+          _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Location.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Location::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Location)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional double degreesLatitude = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target);
+  }
+
+  // optional double degreesLongitude = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target);
+  }
+
+  // optional string name = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Location.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Location)
+  return target;
+}
+
+size_t Location::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Location)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string name = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional double degreesLatitude = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 8;
+    }
+
+    // optional double degreesLongitude = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 8;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Location::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Location::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Location::GetClassData() const { return &_class_data_; }
+
+
+void Location::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Location*>(&to_msg);
+  auto& from = static_cast<const Location&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Location)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Location::CopyFrom(const Location& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Location)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Location::IsInitialized() const {
+  return true;
+}
+
+void Location::InternalSwap(Location* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslongitude_)
+      + sizeof(Location::_impl_.degreeslongitude_)
+      - PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslatitude_)>(
+          reinterpret_cast<char*>(&_impl_.degreeslatitude_),
+          reinterpret_cast<char*>(&other->_impl_.degreeslatitude_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Location::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[50]);
+}
+
+// ===================================================================
+
+class MediaData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MediaData>()._impl_._has_bits_);
+  static void set_has_localpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+MediaData::MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MediaData)
+}
+MediaData::MediaData(const MediaData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MediaData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localpath_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.localpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localpath()) {
+    _this->_impl_.localpath_.Set(from._internal_localpath(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.MediaData)
+}
+
+inline void MediaData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localpath_){}
+  };
+  _impl_.localpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MediaData::~MediaData() {
+  // @@protoc_insertion_point(destructor:proto.MediaData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MediaData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.localpath_.Destroy();
+}
+
+void MediaData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MediaData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MediaData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.localpath_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string localPath = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_localpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MediaData.localPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MediaData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MediaData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string localPath = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_localpath().data(), static_cast<int>(this->_internal_localpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MediaData.localPath");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_localpath(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MediaData)
+  return target;
+}
+
+size_t MediaData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MediaData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string localPath = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_localpath());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MediaData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaData::GetClassData() const { return &_class_data_; }
+
+
+void MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MediaData*>(&to_msg);
+  auto& from = static_cast<const MediaData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_localpath()) {
+    _this->_internal_set_localpath(from._internal_localpath());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MediaData::CopyFrom(const MediaData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MediaData::IsInitialized() const {
+  return true;
+}
+
+void MediaData::InternalSwap(MediaData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localpath_, lhs_arena,
+      &other->_impl_.localpath_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MediaData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[51]);
+}
+
+// ===================================================================
+
+class MediaRetryNotification::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MediaRetryNotification>()._impl_._has_bits_);
+  static void set_has_stanzaid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_result(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+MediaRetryNotification::MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MediaRetryNotification)
+}
+MediaRetryNotification::MediaRetryNotification(const MediaRetryNotification& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MediaRetryNotification* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.result_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_stanzaid()) {
+    _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.result_ = from._impl_.result_;
+  // @@protoc_insertion_point(copy_constructor:proto.MediaRetryNotification)
+}
+
+inline void MediaRetryNotification::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.result_){0}
+  };
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MediaRetryNotification::~MediaRetryNotification() {
+  // @@protoc_insertion_point(destructor:proto.MediaRetryNotification)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MediaRetryNotification::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.stanzaid_.Destroy();
+  _impl_.directpath_.Destroy();
+}
+
+void MediaRetryNotification::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MediaRetryNotification::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MediaRetryNotification)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.stanzaid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.result_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MediaRetryNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string stanzaId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_stanzaid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.stanzaId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaRetryNotification.ResultType result = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) {
+            _internal_set_result(static_cast<::proto::MediaRetryNotification_ResultType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MediaRetryNotification::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MediaRetryNotification)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string stanzaId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_stanzaid().data(), static_cast<int>(this->_internal_stanzaid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MediaRetryNotification.stanzaId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_stanzaid(), target);
+  }
+
+  // optional string directPath = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MediaRetryNotification.directPath");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_directpath(), target);
+  }
+
+  // optional .proto.MediaRetryNotification.ResultType result = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_result(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MediaRetryNotification)
+  return target;
+}
+
+size_t MediaRetryNotification::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MediaRetryNotification)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string stanzaId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_stanzaid());
+    }
+
+    // optional string directPath = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional .proto.MediaRetryNotification.ResultType result = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_result());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaRetryNotification::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MediaRetryNotification::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaRetryNotification::GetClassData() const { return &_class_data_; }
+
+
+void MediaRetryNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MediaRetryNotification*>(&to_msg);
+  auto& from = static_cast<const MediaRetryNotification&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaRetryNotification)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_stanzaid(from._internal_stanzaid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.result_ = from._impl_.result_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MediaRetryNotification::CopyFrom(const MediaRetryNotification& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaRetryNotification)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MediaRetryNotification::IsInitialized() const {
+  return true;
+}
+
+void MediaRetryNotification::InternalSwap(MediaRetryNotification* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.stanzaid_, lhs_arena,
+      &other->_impl_.stanzaid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  swap(_impl_.result_, other->_impl_.result_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MediaRetryNotification::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[52]);
+}
+
+// ===================================================================
+
+class Message_AppStateFatalExceptionNotification::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AppStateFatalExceptionNotification>()._impl_._has_bits_);
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateFatalExceptionNotification)
+}
+Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateFatalExceptionNotification* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.collectionnames_){from._impl_.collectionnames_}
+    , decltype(_impl_.timestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.timestamp_ = from._impl_.timestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateFatalExceptionNotification)
+}
+
+inline void Message_AppStateFatalExceptionNotification::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.collectionnames_){arena}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+  };
+}
+
+Message_AppStateFatalExceptionNotification::~Message_AppStateFatalExceptionNotification() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateFatalExceptionNotification)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateFatalExceptionNotification::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.collectionnames_.~RepeatedPtrField();
+}
+
+void Message_AppStateFatalExceptionNotification::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateFatalExceptionNotification::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateFatalExceptionNotification)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.collectionnames_.Clear();
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateFatalExceptionNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string collectionNames = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_collectionnames();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.Message.AppStateFatalExceptionNotification.collectionNames");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateFatalExceptionNotification::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateFatalExceptionNotification)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string collectionNames = 1;
+  for (int i = 0, n = this->_internal_collectionnames_size(); i < n; i++) {
+    const auto& s = this->_internal_collectionnames(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.AppStateFatalExceptionNotification.collectionNames");
+    target = stream->WriteString(1, s, target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 timestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateFatalExceptionNotification)
+  return target;
+}
+
+size_t Message_AppStateFatalExceptionNotification::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateFatalExceptionNotification)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string collectionNames = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.collectionnames_.size());
+  for (int i = 0, n = _impl_.collectionnames_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.collectionnames_.Get(i));
+  }
+
+  // optional int64 timestamp = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateFatalExceptionNotification::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateFatalExceptionNotification::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateFatalExceptionNotification::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateFatalExceptionNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateFatalExceptionNotification*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateFatalExceptionNotification&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateFatalExceptionNotification)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.collectionnames_.MergeFrom(from._impl_.collectionnames_);
+  if (from._internal_has_timestamp()) {
+    _this->_internal_set_timestamp(from._internal_timestamp());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateFatalExceptionNotification::CopyFrom(const Message_AppStateFatalExceptionNotification& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateFatalExceptionNotification)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateFatalExceptionNotification::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateFatalExceptionNotification::InternalSwap(Message_AppStateFatalExceptionNotification* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.collectionnames_.InternalSwap(&other->_impl_.collectionnames_);
+  swap(_impl_.timestamp_, other->_impl_.timestamp_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateFatalExceptionNotification::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[53]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKeyData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AppStateSyncKeyData>()._impl_._has_bits_);
+  static void set_has_keydata(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint(const Message_AppStateSyncKeyData* msg);
+  static void set_has_fingerprint(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::Message_AppStateSyncKeyFingerprint&
+Message_AppStateSyncKeyData::_Internal::fingerprint(const Message_AppStateSyncKeyData* msg) {
+  return *msg->_impl_.fingerprint_;
+}
+Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyData)
+}
+Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKeyData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keydata_){}
+    , decltype(_impl_.fingerprint_){nullptr}
+    , decltype(_impl_.timestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.keydata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.keydata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_keydata()) {
+    _this->_impl_.keydata_.Set(from._internal_keydata(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_fingerprint()) {
+    _this->_impl_.fingerprint_ = new ::proto::Message_AppStateSyncKeyFingerprint(*from._impl_.fingerprint_);
+  }
+  _this->_impl_.timestamp_ = from._impl_.timestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyData)
+}
+
+inline void Message_AppStateSyncKeyData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keydata_){}
+    , decltype(_impl_.fingerprint_){nullptr}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+  };
+  _impl_.keydata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.keydata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_AppStateSyncKeyData::~Message_AppStateSyncKeyData() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKeyData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.keydata_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.fingerprint_;
+}
+
+void Message_AppStateSyncKeyData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKeyData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.keydata_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.fingerprint_ != nullptr);
+      _impl_.fingerprint_->Clear();
+    }
+  }
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKeyData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes keyData = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_keydata();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fingerprint(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 timestamp = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKeyData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes keyData = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_keydata(), target);
+  }
+
+  // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::fingerprint(this),
+        _Internal::fingerprint(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 timestamp = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKeyData)
+  return target;
+}
+
+size_t Message_AppStateSyncKeyData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes keyData = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_keydata());
+    }
+
+    // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.fingerprint_);
+    }
+
+    // optional int64 timestamp = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKeyData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyData::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKeyData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKeyData*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKeyData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_keydata(from._internal_keydata());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_fingerprint()->::proto::Message_AppStateSyncKeyFingerprint::MergeFrom(
+          from._internal_fingerprint());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKeyData::CopyFrom(const Message_AppStateSyncKeyData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKeyData::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKeyData::InternalSwap(Message_AppStateSyncKeyData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.keydata_, lhs_arena,
+      &other->_impl_.keydata_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.timestamp_)
+      + sizeof(Message_AppStateSyncKeyData::_impl_.timestamp_)
+      - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.fingerprint_)>(
+          reinterpret_cast<char*>(&_impl_.fingerprint_),
+          reinterpret_cast<char*>(&other->_impl_.fingerprint_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[54]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKeyFingerprint::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AppStateSyncKeyFingerprint>()._impl_._has_bits_);
+  static void set_has_rawid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_currentindex(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyFingerprint)
+}
+Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKeyFingerprint* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.deviceindexes_){from._impl_.deviceindexes_}
+    , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.rawid_){}
+    , decltype(_impl_.currentindex_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.rawid_, &from._impl_.rawid_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.currentindex_) -
+    reinterpret_cast<char*>(&_impl_.rawid_)) + sizeof(_impl_.currentindex_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyFingerprint)
+}
+
+inline void Message_AppStateSyncKeyFingerprint::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.deviceindexes_){arena}
+    , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0}
+    , decltype(_impl_.rawid_){0u}
+    , decltype(_impl_.currentindex_){0u}
+  };
+}
+
+Message_AppStateSyncKeyFingerprint::~Message_AppStateSyncKeyFingerprint() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyFingerprint)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKeyFingerprint::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.deviceindexes_.~RepeatedField();
+}
+
+void Message_AppStateSyncKeyFingerprint::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKeyFingerprint::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyFingerprint)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.deviceindexes_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.rawid_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.currentindex_) -
+        reinterpret_cast<char*>(&_impl_.rawid_)) + sizeof(_impl_.currentindex_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKeyFingerprint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 rawId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_rawid(&has_bits);
+          _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 currentIndex = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_currentindex(&has_bits);
+          _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 deviceIndexes = 3 [packed = true];
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_deviceindexes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 24) {
+          _internal_add_deviceindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKeyFingerprint::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyFingerprint)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 rawId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target);
+  }
+
+  // optional uint32 currentIndex = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_currentindex(), target);
+  }
+
+  // repeated uint32 deviceIndexes = 3 [packed = true];
+  {
+    int byte_size = _impl_._deviceindexes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt32Packed(
+          3, _internal_deviceindexes(), byte_size, target);
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKeyFingerprint)
+  return target;
+}
+
+size_t Message_AppStateSyncKeyFingerprint::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyFingerprint)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated uint32 deviceIndexes = 3 [packed = true];
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.deviceindexes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._deviceindexes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional uint32 rawId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid());
+    }
+
+    // optional uint32 currentIndex = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyFingerprint::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKeyFingerprint::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyFingerprint::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKeyFingerprint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKeyFingerprint*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKeyFingerprint&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyFingerprint)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.deviceindexes_.MergeFrom(from._impl_.deviceindexes_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.rawid_ = from._impl_.rawid_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.currentindex_ = from._impl_.currentindex_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKeyFingerprint::CopyFrom(const Message_AppStateSyncKeyFingerprint& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyFingerprint)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKeyFingerprint::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKeyFingerprint::InternalSwap(Message_AppStateSyncKeyFingerprint* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.deviceindexes_.InternalSwap(&other->_impl_.deviceindexes_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.currentindex_)
+      + sizeof(Message_AppStateSyncKeyFingerprint::_impl_.currentindex_)
+      - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.rawid_)>(
+          reinterpret_cast<char*>(&_impl_.rawid_),
+          reinterpret_cast<char*>(&other->_impl_.rawid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyFingerprint::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[55]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKeyId::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AppStateSyncKeyId>()._impl_._has_bits_);
+  static void set_has_keyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyId)
+}
+Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKeyId* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keyid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.keyid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.keyid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_keyid()) {
+    _this->_impl_.keyid_.Set(from._internal_keyid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyId)
+}
+
+inline void Message_AppStateSyncKeyId::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keyid_){}
+  };
+  _impl_.keyid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.keyid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_AppStateSyncKeyId::~Message_AppStateSyncKeyId() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyId)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKeyId::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.keyid_.Destroy();
+}
+
+void Message_AppStateSyncKeyId::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKeyId::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyId)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.keyid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes keyId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_keyid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKeyId::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyId)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes keyId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_keyid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKeyId)
+  return target;
+}
+
+size_t Message_AppStateSyncKeyId::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyId)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes keyId = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_keyid());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyId::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKeyId::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyId::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKeyId*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKeyId&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyId)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_keyid()) {
+    _this->_internal_set_keyid(from._internal_keyid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKeyId::CopyFrom(const Message_AppStateSyncKeyId& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyId)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKeyId::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKeyId::InternalSwap(Message_AppStateSyncKeyId* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.keyid_, lhs_arena,
+      &other->_impl_.keyid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyId::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[56]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKeyRequest::_Internal {
+ public:
+};
+
+Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyRequest)
+}
+Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKeyRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.keyids_){from._impl_.keyids_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyRequest)
+}
+
+inline void Message_AppStateSyncKeyRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.keyids_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Message_AppStateSyncKeyRequest::~Message_AppStateSyncKeyRequest() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKeyRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.keyids_.~RepeatedPtrField();
+}
+
+void Message_AppStateSyncKeyRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKeyRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.keyids_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKeyRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_keyids(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKeyRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_keyids_size()); i < n; i++) {
+    const auto& repfield = this->_internal_keyids(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKeyRequest)
+  return target;
+}
+
+size_t Message_AppStateSyncKeyRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
+  total_size += 1UL * this->_internal_keyids_size();
+  for (const auto& msg : this->_impl_.keyids_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKeyRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyRequest::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKeyRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKeyRequest*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKeyRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.keyids_.MergeFrom(from._impl_.keyids_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKeyRequest::CopyFrom(const Message_AppStateSyncKeyRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKeyRequest::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKeyRequest::InternalSwap(Message_AppStateSyncKeyRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.keyids_.InternalSwap(&other->_impl_.keyids_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[57]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKeyShare::_Internal {
+ public:
+};
+
+Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyShare)
+}
+Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKeyShare* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.keys_){from._impl_.keys_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyShare)
+}
+
+inline void Message_AppStateSyncKeyShare::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.keys_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Message_AppStateSyncKeyShare::~Message_AppStateSyncKeyShare() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyShare)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKeyShare::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.keys_.~RepeatedPtrField();
+}
+
+void Message_AppStateSyncKeyShare::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKeyShare::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyShare)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.keys_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKeyShare::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.Message.AppStateSyncKey keys = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_keys(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKeyShare::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyShare)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.AppStateSyncKey keys = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_keys_size()); i < n; i++) {
+    const auto& repfield = this->_internal_keys(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKeyShare)
+  return target;
+}
+
+size_t Message_AppStateSyncKeyShare::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyShare)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.AppStateSyncKey keys = 1;
+  total_size += 1UL * this->_internal_keys_size();
+  for (const auto& msg : this->_impl_.keys_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyShare::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKeyShare::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyShare::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKeyShare::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKeyShare*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKeyShare&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyShare)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.keys_.MergeFrom(from._impl_.keys_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKeyShare::CopyFrom(const Message_AppStateSyncKeyShare& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyShare)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKeyShare::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKeyShare::InternalSwap(Message_AppStateSyncKeyShare* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.keys_.InternalSwap(&other->_impl_.keys_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyShare::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[58]);
+}
+
+// ===================================================================
+
+class Message_AppStateSyncKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AppStateSyncKey>()._impl_._has_bits_);
+  static const ::proto::Message_AppStateSyncKeyId& keyid(const Message_AppStateSyncKey* msg);
+  static void set_has_keyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_AppStateSyncKeyData& keydata(const Message_AppStateSyncKey* msg);
+  static void set_has_keydata(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_AppStateSyncKeyId&
+Message_AppStateSyncKey::_Internal::keyid(const Message_AppStateSyncKey* msg) {
+  return *msg->_impl_.keyid_;
+}
+const ::proto::Message_AppStateSyncKeyData&
+Message_AppStateSyncKey::_Internal::keydata(const Message_AppStateSyncKey* msg) {
+  return *msg->_impl_.keydata_;
+}
+Message_AppStateSyncKey::Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKey)
+}
+Message_AppStateSyncKey::Message_AppStateSyncKey(const Message_AppStateSyncKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AppStateSyncKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keyid_){nullptr}
+    , decltype(_impl_.keydata_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_keyid()) {
+    _this->_impl_.keyid_ = new ::proto::Message_AppStateSyncKeyId(*from._impl_.keyid_);
+  }
+  if (from._internal_has_keydata()) {
+    _this->_impl_.keydata_ = new ::proto::Message_AppStateSyncKeyData(*from._impl_.keydata_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKey)
+}
+
+inline void Message_AppStateSyncKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keyid_){nullptr}
+    , decltype(_impl_.keydata_){nullptr}
+  };
+}
+
+Message_AppStateSyncKey::~Message_AppStateSyncKey() {
+  // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AppStateSyncKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.keyid_;
+  if (this != internal_default_instance()) delete _impl_.keydata_;
+}
+
+void Message_AppStateSyncKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AppStateSyncKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.keyid_ != nullptr);
+      _impl_.keyid_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.keydata_ != nullptr);
+      _impl_.keydata_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AppStateSyncKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.AppStateSyncKeyId keyId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AppStateSyncKeyData keyData = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keydata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AppStateSyncKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.AppStateSyncKeyId keyId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::keyid(this),
+        _Internal::keyid(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.AppStateSyncKeyData keyData = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::keydata(this),
+        _Internal::keydata(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AppStateSyncKey)
+  return target;
+}
+
+size_t Message_AppStateSyncKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.Message.AppStateSyncKeyId keyId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keyid_);
+    }
+
+    // optional .proto.Message.AppStateSyncKeyData keyData = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keydata_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AppStateSyncKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKey::GetClassData() const { return &_class_data_; }
+
+
+void Message_AppStateSyncKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AppStateSyncKey*>(&to_msg);
+  auto& from = static_cast<const Message_AppStateSyncKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_keyid()->::proto::Message_AppStateSyncKeyId::MergeFrom(
+          from._internal_keyid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_keydata()->::proto::Message_AppStateSyncKeyData::MergeFrom(
+          from._internal_keydata());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AppStateSyncKey::CopyFrom(const Message_AppStateSyncKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AppStateSyncKey::IsInitialized() const {
+  return true;
+}
+
+void Message_AppStateSyncKey::InternalSwap(Message_AppStateSyncKey* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keydata_)
+      + sizeof(Message_AppStateSyncKey::_impl_.keydata_)
+      - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keyid_)>(
+          reinterpret_cast<char*>(&_impl_.keyid_),
+          reinterpret_cast<char*>(&other->_impl_.keyid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[59]);
+}
+
+// ===================================================================
+
+class Message_AudioMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_AudioMessage>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_seconds(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_ptt(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_AudioMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_streamingsidecar(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_waveform(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_AudioMessage::_Internal::contextinfo(const Message_AudioMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_AudioMessage::Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.AudioMessage)
+}
+Message_AudioMessage::Message_AudioMessage(const Message_AudioMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_AudioMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.streamingsidecar_){}
+    , decltype(_impl_.waveform_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.seconds_){}
+    , decltype(_impl_.ptt_){}
+    , decltype(_impl_.mediakeytimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.streamingsidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_streamingsidecar()) {
+    _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.waveform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.waveform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_waveform()) {
+    _this->_impl_.waveform_.Set(from._internal_waveform(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.mediakeytimestamp_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.AudioMessage)
+}
+
+inline void Message_AudioMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.streamingsidecar_){}
+    , decltype(_impl_.waveform_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.seconds_){0u}
+    , decltype(_impl_.ptt_){false}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.streamingsidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.waveform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.waveform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_AudioMessage::~Message_AudioMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.AudioMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_AudioMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.streamingsidecar_.Destroy();
+  _impl_.waveform_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_AudioMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_AudioMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.AudioMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.streamingsidecar_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.waveform_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000100u) {
+    GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+    _impl_.contextinfo_->Clear();
+  }
+  if (cached_has_bits & 0x00001e00u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.mediakeytimestamp_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_AudioMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 seconds = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_seconds(&has_bits);
+          _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool ptt = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_ptt(&has_bits);
+          _impl_.ptt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes streamingSidecar = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          auto str = _internal_mutable_streamingsidecar();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes waveform = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_waveform();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_AudioMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AudioMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.AudioMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string mimetype = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.AudioMessage.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_mimetype(), target);
+  }
+
+  // optional bytes fileSha256 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_filesha256(), target);
+  }
+
+  // optional uint64 fileLength = 4;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target);
+  }
+
+  // optional uint32 seconds = 5;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target);
+  }
+
+  // optional bool ptt = 6;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_ptt(), target);
+  }
+
+  // optional bytes mediaKey = 7;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        7, this->_internal_mediakey(), target);
+  }
+
+  // optional bytes fileEncSha256 = 8;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_fileencsha256(), target);
+  }
+
+  // optional string directPath = 9;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.AudioMessage.directPath");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_directpath(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 10;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes streamingSidecar = 18;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        18, this->_internal_streamingsidecar(), target);
+  }
+
+  // optional bytes waveform = 19;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        19, this->_internal_waveform(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.AudioMessage)
+  return target;
+}
+
+size_t Message_AudioMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.AudioMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string mimetype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional bytes fileSha256 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes mediaKey = 7;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional bytes fileEncSha256 = 8;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 9;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional bytes streamingSidecar = 18;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_streamingsidecar());
+    }
+
+    // optional bytes waveform = 19;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_waveform());
+    }
+
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint64 fileLength = 4;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional uint32 seconds = 5;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds());
+    }
+
+    // optional bool ptt = 6;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 + 1;
+    }
+
+    // optional int64 mediaKeyTimestamp = 10;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AudioMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_AudioMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AudioMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_AudioMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_AudioMessage*>(&to_msg);
+  auto& from = static_cast<const Message_AudioMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AudioMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_streamingsidecar(from._internal_streamingsidecar());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_waveform(from._internal_waveform());
+    }
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.seconds_ = from._impl_.seconds_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.ptt_ = from._impl_.ptt_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_AudioMessage::CopyFrom(const Message_AudioMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AudioMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_AudioMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_AudioMessage::InternalSwap(Message_AudioMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.streamingsidecar_, lhs_arena,
+      &other->_impl_.streamingsidecar_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.waveform_, lhs_arena,
+      &other->_impl_.waveform_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.mediakeytimestamp_)
+      + sizeof(Message_AudioMessage::_impl_.mediakeytimestamp_)
+      - PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_AudioMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[60]);
+}
+
+// ===================================================================
+
+class Message_ButtonsMessage_Button_ButtonText::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ButtonsMessage_Button_ButtonText>()._impl_._has_bits_);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.ButtonText)
+}
+Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ButtonsMessage_Button_ButtonText* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_.Set(from._internal_displaytext(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.ButtonText)
+}
+
+inline void Message_ButtonsMessage_Button_ButtonText::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){}
+  };
+  _impl_.displaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ButtonsMessage_Button_ButtonText::~Message_ButtonsMessage_Button_ButtonText() {
+  // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.ButtonText)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ButtonsMessage_Button_ButtonText::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displaytext_.Destroy();
+}
+
+void Message_ButtonsMessage_Button_ButtonText::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ButtonsMessage_Button_ButtonText::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.ButtonText)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.displaytext_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ButtonsMessage_Button_ButtonText::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.ButtonText.displayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ButtonsMessage_Button_ButtonText::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.ButtonText)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displaytext().data(), static_cast<int>(this->_internal_displaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.Button.ButtonText.displayText");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displaytext(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ButtonsMessage.Button.ButtonText)
+  return target;
+}
+
+size_t Message_ButtonsMessage_Button_ButtonText::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.ButtonText)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string displayText = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_displaytext());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_ButtonText::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ButtonsMessage_Button_ButtonText::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_ButtonText::GetClassData() const { return &_class_data_; }
+
+
+void Message_ButtonsMessage_Button_ButtonText::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ButtonsMessage_Button_ButtonText*>(&to_msg);
+  auto& from = static_cast<const Message_ButtonsMessage_Button_ButtonText&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.ButtonText)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_displaytext()) {
+    _this->_internal_set_displaytext(from._internal_displaytext());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ButtonsMessage_Button_ButtonText::CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.ButtonText)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ButtonsMessage_Button_ButtonText::IsInitialized() const {
+  return true;
+}
+
+void Message_ButtonsMessage_Button_ButtonText::InternalSwap(Message_ButtonsMessage_Button_ButtonText* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displaytext_, lhs_arena,
+      &other->_impl_.displaytext_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_ButtonText::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[61]);
+}
+
+// ===================================================================
+
+class Message_ButtonsMessage_Button_NativeFlowInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ButtonsMessage_Button_NativeFlowInfo>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_paramsjson(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+}
+Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ButtonsMessage_Button_NativeFlowInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.paramsjson_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.paramsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_paramsjson()) {
+    _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+}
+
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.paramsjson_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.paramsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ButtonsMessage_Button_NativeFlowInfo::~Message_ButtonsMessage_Button_NativeFlowInfo() {
+  // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.paramsjson_.Destroy();
+}
+
+void Message_ButtonsMessage_Button_NativeFlowInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ButtonsMessage_Button_NativeFlowInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.paramsjson_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string paramsJson = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_paramsjson();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional string paramsJson = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_paramsjson().data(), static_cast<int>(this->_internal_paramsjson().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_paramsjson(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  return target;
+}
+
+size_t Message_ButtonsMessage_Button_NativeFlowInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string paramsJson = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_paramsjson());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_NativeFlowInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_NativeFlowInfo::GetClassData() const { return &_class_data_; }
+
+
+void Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ButtonsMessage_Button_NativeFlowInfo*>(&to_msg);
+  auto& from = static_cast<const Message_ButtonsMessage_Button_NativeFlowInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_paramsjson(from._internal_paramsjson());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ButtonsMessage_Button_NativeFlowInfo::CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ButtonsMessage_Button_NativeFlowInfo::IsInitialized() const {
+  return true;
+}
+
+void Message_ButtonsMessage_Button_NativeFlowInfo::InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.paramsjson_, lhs_arena,
+      &other->_impl_.paramsjson_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_NativeFlowInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[62]);
+}
+
+// ===================================================================
+
+class Message_ButtonsMessage_Button::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ButtonsMessage_Button>()._impl_._has_bits_);
+  static void set_has_buttonid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext(const Message_ButtonsMessage_Button* msg);
+  static void set_has_buttontext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo(const Message_ButtonsMessage_Button* msg);
+  static void set_has_nativeflowinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::Message_ButtonsMessage_Button_ButtonText&
+Message_ButtonsMessage_Button::_Internal::buttontext(const Message_ButtonsMessage_Button* msg) {
+  return *msg->_impl_.buttontext_;
+}
+const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo&
+Message_ButtonsMessage_Button::_Internal::nativeflowinfo(const Message_ButtonsMessage_Button* msg) {
+  return *msg->_impl_.nativeflowinfo_;
+}
+Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button)
+}
+Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ButtonsMessage_Button* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttonid_){}
+    , decltype(_impl_.buttontext_){nullptr}
+    , decltype(_impl_.nativeflowinfo_){nullptr}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.buttonid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttonid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_buttonid()) {
+    _this->_impl_.buttonid_.Set(from._internal_buttonid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_buttontext()) {
+    _this->_impl_.buttontext_ = new ::proto::Message_ButtonsMessage_Button_ButtonText(*from._impl_.buttontext_);
+  }
+  if (from._internal_has_nativeflowinfo()) {
+    _this->_impl_.nativeflowinfo_ = new ::proto::Message_ButtonsMessage_Button_NativeFlowInfo(*from._impl_.nativeflowinfo_);
+  }
+  _this->_impl_.type_ = from._impl_.type_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button)
+}
+
+inline void Message_ButtonsMessage_Button::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttonid_){}
+    , decltype(_impl_.buttontext_){nullptr}
+    , decltype(_impl_.nativeflowinfo_){nullptr}
+    , decltype(_impl_.type_){0}
+  };
+  _impl_.buttonid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttonid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ButtonsMessage_Button::~Message_ButtonsMessage_Button() {
+  // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ButtonsMessage_Button::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.buttonid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.buttontext_;
+  if (this != internal_default_instance()) delete _impl_.nativeflowinfo_;
+}
+
+void Message_ButtonsMessage_Button::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ButtonsMessage_Button::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.buttonid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.buttontext_ != nullptr);
+      _impl_.buttontext_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.nativeflowinfo_ != nullptr);
+      _impl_.nativeflowinfo_->Clear();
+    }
+  }
+  _impl_.type_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ButtonsMessage_Button::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string buttonId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_buttonid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.buttonId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_buttontext(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsMessage.Button.Type type = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_Button_Type_IsValid(val))) {
+            _internal_set_type(static_cast<::proto::Message_ButtonsMessage_Button_Type>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_nativeflowinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ButtonsMessage_Button::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string buttonId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_buttonid().data(), static_cast<int>(this->_internal_buttonid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.Button.buttonId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_buttonid(), target);
+  }
+
+  // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::buttontext(this),
+        _Internal::buttontext(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ButtonsMessage.Button.Type type = 3;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_type(), target);
+  }
+
+  // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::nativeflowinfo(this),
+        _Internal::nativeflowinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ButtonsMessage.Button)
+  return target;
+}
+
+size_t Message_ButtonsMessage_Button::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string buttonId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_buttonid());
+    }
+
+    // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.buttontext_);
+    }
+
+    // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.nativeflowinfo_);
+    }
+
+    // optional .proto.Message.ButtonsMessage.Button.Type type = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ButtonsMessage_Button::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button::GetClassData() const { return &_class_data_; }
+
+
+void Message_ButtonsMessage_Button::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ButtonsMessage_Button*>(&to_msg);
+  auto& from = static_cast<const Message_ButtonsMessage_Button&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_buttonid(from._internal_buttonid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_buttontext()->::proto::Message_ButtonsMessage_Button_ButtonText::MergeFrom(
+          from._internal_buttontext());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_nativeflowinfo()->::proto::Message_ButtonsMessage_Button_NativeFlowInfo::MergeFrom(
+          from._internal_nativeflowinfo());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ButtonsMessage_Button::CopyFrom(const Message_ButtonsMessage_Button& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ButtonsMessage_Button::IsInitialized() const {
+  return true;
+}
+
+void Message_ButtonsMessage_Button::InternalSwap(Message_ButtonsMessage_Button* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.buttonid_, lhs_arena,
+      &other->_impl_.buttonid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.type_)
+      + sizeof(Message_ButtonsMessage_Button::_impl_.type_)
+      - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.buttontext_)>(
+          reinterpret_cast<char*>(&_impl_.buttontext_),
+          reinterpret_cast<char*>(&other->_impl_.buttontext_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[63]);
+}
+
+// ===================================================================
+
+class Message_ButtonsMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ButtonsMessage>()._impl_._has_bits_);
+  static void set_has_contenttext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_footertext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ButtonsMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_headertype(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Message_DocumentMessage& documentmessage(const Message_ButtonsMessage* msg);
+  static const ::proto::Message_ImageMessage& imagemessage(const Message_ButtonsMessage* msg);
+  static const ::proto::Message_VideoMessage& videomessage(const Message_ButtonsMessage* msg);
+  static const ::proto::Message_LocationMessage& locationmessage(const Message_ButtonsMessage* msg);
+};
+
+const ::proto::ContextInfo&
+Message_ButtonsMessage::_Internal::contextinfo(const Message_ButtonsMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+const ::proto::Message_DocumentMessage&
+Message_ButtonsMessage::_Internal::documentmessage(const Message_ButtonsMessage* msg) {
+  return *msg->_impl_.header_.documentmessage_;
+}
+const ::proto::Message_ImageMessage&
+Message_ButtonsMessage::_Internal::imagemessage(const Message_ButtonsMessage* msg) {
+  return *msg->_impl_.header_.imagemessage_;
+}
+const ::proto::Message_VideoMessage&
+Message_ButtonsMessage::_Internal::videomessage(const Message_ButtonsMessage* msg) {
+  return *msg->_impl_.header_.videomessage_;
+}
+const ::proto::Message_LocationMessage&
+Message_ButtonsMessage::_Internal::locationmessage(const Message_ButtonsMessage* msg) {
+  return *msg->_impl_.header_.locationmessage_;
+}
+void Message_ButtonsMessage::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_header();
+  if (documentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
+    if (message_arena != submessage_arena) {
+      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentmessage, submessage_arena);
+    }
+    set_has_documentmessage();
+    _impl_.header_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.documentMessage)
+}
+void Message_ButtonsMessage::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_header();
+  if (imagemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
+    if (message_arena != submessage_arena) {
+      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, imagemessage, submessage_arena);
+    }
+    set_has_imagemessage();
+    _impl_.header_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.imageMessage)
+}
+void Message_ButtonsMessage::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_header();
+  if (videomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
+    if (message_arena != submessage_arena) {
+      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, videomessage, submessage_arena);
+    }
+    set_has_videomessage();
+    _impl_.header_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.videoMessage)
+}
+void Message_ButtonsMessage::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_header();
+  if (locationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage);
+    if (message_arena != submessage_arena) {
+      locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, locationmessage, submessage_arena);
+    }
+    set_has_locationmessage();
+    _impl_.header_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.locationMessage)
+}
+Message_ButtonsMessage::Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage)
+}
+Message_ButtonsMessage::Message_ButtonsMessage(const Message_ButtonsMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ButtonsMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){from._impl_.buttons_}
+    , decltype(_impl_.contenttext_){}
+    , decltype(_impl_.footertext_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.headertype_){}
+    , decltype(_impl_.header_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.contenttext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.contenttext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_contenttext()) {
+    _this->_impl_.contenttext_.Set(from._internal_contenttext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.footertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_footertext()) {
+    _this->_impl_.footertext_.Set(from._internal_footertext(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.headertype_ = from._impl_.headertype_;
+  clear_has_header();
+  switch (from.header_case()) {
+    case kText: {
+      _this->_internal_set_text(from._internal_text());
+      break;
+    }
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case HEADER_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage)
+}
+
+inline void Message_ButtonsMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){arena}
+    , decltype(_impl_.contenttext_){}
+    , decltype(_impl_.footertext_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.headertype_){0}
+    , decltype(_impl_.header_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  _impl_.contenttext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.contenttext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.footertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  clear_has_header();
+}
+
+Message_ButtonsMessage::~Message_ButtonsMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ButtonsMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.buttons_.~RepeatedPtrField();
+  _impl_.contenttext_.Destroy();
+  _impl_.footertext_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+  if (has_header()) {
+    clear_header();
+  }
+}
+
+void Message_ButtonsMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ButtonsMessage::clear_header() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsMessage)
+  switch (header_case()) {
+    case kText: {
+      _impl_.header_.text_.Destroy();
+      break;
+    }
+    case kDocumentMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.header_.documentmessage_;
+      }
+      break;
+    }
+    case kImageMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.header_.imagemessage_;
+      }
+      break;
+    }
+    case kVideoMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.header_.videomessage_;
+      }
+      break;
+    }
+    case kLocationMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.header_.locationmessage_;
+      }
+      break;
+    }
+    case HEADER_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = HEADER_NOT_SET;
+}
+
+
+void Message_ButtonsMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.buttons_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.contenttext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.footertext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.headertype_ = 0;
+  clear_header();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ButtonsMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string text = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.DocumentMessage documentMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.ImageMessage imageMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.VideoMessage videoMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.LocationMessage locationMessage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string contentText = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_contenttext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.contentText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string footerText = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_footertext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.footerText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.ButtonsMessage.Button buttons = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_buttons(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_HeaderType_IsValid(val))) {
+            _internal_set_headertype(static_cast<::proto::Message_ButtonsMessage_HeaderType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ButtonsMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (header_case()) {
+    case kText: {
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+        this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+        "proto.Message.ButtonsMessage.text");
+      target = stream->WriteStringMaybeAliased(
+          1, this->_internal_text(), target);
+      break;
+    }
+    case kDocumentMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::documentmessage(this),
+          _Internal::documentmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kImageMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::imagemessage(this),
+          _Internal::imagemessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kVideoMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, _Internal::videomessage(this),
+          _Internal::videomessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kLocationMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, _Internal::locationmessage(this),
+          _Internal::locationmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string contentText = 6;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_contenttext().data(), static_cast<int>(this->_internal_contenttext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.contentText");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_contenttext(), target);
+  }
+
+  // optional string footerText = 7;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_footertext().data(), static_cast<int>(this->_internal_footertext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsMessage.footerText");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_footertext(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 8;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.Message.ButtonsMessage.Button buttons = 9;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_buttons_size()); i < n; i++) {
+    const auto& repfield = this->_internal_buttons(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_headertype(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ButtonsMessage)
+  return target;
+}
+
+size_t Message_ButtonsMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ButtonsMessage.Button buttons = 9;
+  total_size += 1UL * this->_internal_buttons_size();
+  for (const auto& msg : this->_impl_.buttons_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string contentText = 6;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_contenttext());
+    }
+
+    // optional string footerText = 7;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_footertext());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 8;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_headertype());
+    }
+
+  }
+  switch (header_case()) {
+    // string text = 1;
+    case kText: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_text());
+      break;
+    }
+    // .proto.Message.DocumentMessage documentMessage = 2;
+    case kDocumentMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.header_.documentmessage_);
+      break;
+    }
+    // .proto.Message.ImageMessage imageMessage = 3;
+    case kImageMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.header_.imagemessage_);
+      break;
+    }
+    // .proto.Message.VideoMessage videoMessage = 4;
+    case kVideoMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.header_.videomessage_);
+      break;
+    }
+    // .proto.Message.LocationMessage locationMessage = 5;
+    case kLocationMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.header_.locationmessage_);
+      break;
+    }
+    case HEADER_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ButtonsMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ButtonsMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ButtonsMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ButtonsMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_contenttext(from._internal_contenttext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_footertext(from._internal_footertext());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.headertype_ = from._impl_.headertype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  switch (from.header_case()) {
+    case kText: {
+      _this->_internal_set_text(from._internal_text());
+      break;
+    }
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case HEADER_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ButtonsMessage::CopyFrom(const Message_ButtonsMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ButtonsMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ButtonsMessage::InternalSwap(Message_ButtonsMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.buttons_.InternalSwap(&other->_impl_.buttons_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.contenttext_, lhs_arena,
+      &other->_impl_.contenttext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.footertext_, lhs_arena,
+      &other->_impl_.footertext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.headertype_)
+      + sizeof(Message_ButtonsMessage::_impl_.headertype_)
+      - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+  swap(_impl_.header_, other->_impl_.header_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[64]);
+}
+
+// ===================================================================
+
+class Message_ButtonsResponseMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ButtonsResponseMessage>()._impl_._has_bits_);
+  static void set_has_selectedbuttonid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ButtonsResponseMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_ButtonsResponseMessage::_Internal::contextinfo(const Message_ButtonsResponseMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsResponseMessage)
+}
+Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ButtonsResponseMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedbuttonid_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.type_){}
+    , decltype(_impl_.response_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.selectedbuttonid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_selectedbuttonid()) {
+    _this->_impl_.selectedbuttonid_.Set(from._internal_selectedbuttonid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.type_ = from._impl_.type_;
+  clear_has_response();
+  switch (from.response_case()) {
+    case kSelectedDisplayText: {
+      _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext());
+      break;
+    }
+    case RESPONSE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsResponseMessage)
+}
+
+inline void Message_ButtonsResponseMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedbuttonid_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.type_){0}
+    , decltype(_impl_.response_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  _impl_.selectedbuttonid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  clear_has_response();
+}
+
+Message_ButtonsResponseMessage::~Message_ButtonsResponseMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ButtonsResponseMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ButtonsResponseMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.selectedbuttonid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+  if (has_response()) {
+    clear_response();
+  }
+}
+
+void Message_ButtonsResponseMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ButtonsResponseMessage::clear_response() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsResponseMessage)
+  switch (response_case()) {
+    case kSelectedDisplayText: {
+      _impl_.response_.selecteddisplaytext_.Destroy();
+      break;
+    }
+    case RESPONSE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = RESPONSE_NOT_SET;
+}
+
+
+void Message_ButtonsResponseMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsResponseMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.selectedbuttonid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.type_ = 0;
+  clear_response();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ButtonsResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string selectedButtonId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_selectedbuttonid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedButtonId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // string selectedDisplayText = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_selecteddisplaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedDisplayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsResponseMessage.Type type = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsResponseMessage_Type_IsValid(val))) {
+            _internal_set_type(static_cast<::proto::Message_ButtonsResponseMessage_Type>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ButtonsResponseMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsResponseMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string selectedButtonId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_selectedbuttonid().data(), static_cast<int>(this->_internal_selectedbuttonid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsResponseMessage.selectedButtonId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_selectedbuttonid(), target);
+  }
+
+  // string selectedDisplayText = 2;
+  if (_internal_has_selecteddisplaytext()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_selecteddisplaytext().data(), static_cast<int>(this->_internal_selecteddisplaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ButtonsResponseMessage.selectedDisplayText");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_selecteddisplaytext(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ButtonsResponseMessage.Type type = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ButtonsResponseMessage)
+  return target;
+}
+
+size_t Message_ButtonsResponseMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsResponseMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string selectedButtonId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_selectedbuttonid());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional .proto.Message.ButtonsResponseMessage.Type type = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+  }
+  switch (response_case()) {
+    // string selectedDisplayText = 2;
+    case kSelectedDisplayText: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_selecteddisplaytext());
+      break;
+    }
+    case RESPONSE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsResponseMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ButtonsResponseMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsResponseMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ButtonsResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ButtonsResponseMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ButtonsResponseMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsResponseMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_selectedbuttonid(from._internal_selectedbuttonid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  switch (from.response_case()) {
+    case kSelectedDisplayText: {
+      _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext());
+      break;
+    }
+    case RESPONSE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ButtonsResponseMessage::CopyFrom(const Message_ButtonsResponseMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsResponseMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ButtonsResponseMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ButtonsResponseMessage::InternalSwap(Message_ButtonsResponseMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.selectedbuttonid_, lhs_arena,
+      &other->_impl_.selectedbuttonid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.type_)
+      + sizeof(Message_ButtonsResponseMessage::_impl_.type_)
+      - PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+  swap(_impl_.response_, other->_impl_.response_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsResponseMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[65]);
+}
+
+// ===================================================================
+
+class Message_Call::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_Call>()._impl_._has_bits_);
+  static void set_has_callkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_conversionsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_conversiondata(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_conversiondelayseconds(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+Message_Call::Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.Call)
+}
+Message_Call::Message_Call(const Message_Call& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_Call* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.callkey_){}
+    , decltype(_impl_.conversionsource_){}
+    , decltype(_impl_.conversiondata_){}
+    , decltype(_impl_.conversiondelayseconds_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.callkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.callkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_callkey()) {
+    _this->_impl_.callkey_.Set(from._internal_callkey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.conversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_conversionsource()) {
+    _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.conversiondata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_conversiondata()) {
+    _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.Call)
+}
+
+inline void Message_Call::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.callkey_){}
+    , decltype(_impl_.conversionsource_){}
+    , decltype(_impl_.conversiondata_){}
+    , decltype(_impl_.conversiondelayseconds_){0u}
+  };
+  _impl_.callkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.callkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.conversionsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.conversiondata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_Call::~Message_Call() {
+  // @@protoc_insertion_point(destructor:proto.Message.Call)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_Call::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.callkey_.Destroy();
+  _impl_.conversionsource_.Destroy();
+  _impl_.conversiondata_.Destroy();
+}
+
+void Message_Call::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_Call::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.Call)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.callkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.conversionsource_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.conversiondata_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.conversiondelayseconds_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_Call::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes callKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_callkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string conversionSource = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_conversionsource();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.Call.conversionSource");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes conversionData = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_conversiondata();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 conversionDelaySeconds = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_conversiondelayseconds(&has_bits);
+          _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_Call::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Call)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes callKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_callkey(), target);
+  }
+
+  // optional string conversionSource = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_conversionsource().data(), static_cast<int>(this->_internal_conversionsource().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.Call.conversionSource");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_conversionsource(), target);
+  }
+
+  // optional bytes conversionData = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_conversiondata(), target);
+  }
+
+  // optional uint32 conversionDelaySeconds = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_conversiondelayseconds(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.Call)
+  return target;
+}
+
+size_t Message_Call::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.Call)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes callKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_callkey());
+    }
+
+    // optional string conversionSource = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_conversionsource());
+    }
+
+    // optional bytes conversionData = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_conversiondata());
+    }
+
+    // optional uint32 conversionDelaySeconds = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_conversiondelayseconds());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Call::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_Call::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Call::GetClassData() const { return &_class_data_; }
+
+
+void Message_Call::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_Call*>(&to_msg);
+  auto& from = static_cast<const Message_Call&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Call)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_callkey(from._internal_callkey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_conversionsource(from._internal_conversionsource());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_conversiondata(from._internal_conversiondata());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_Call::CopyFrom(const Message_Call& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Call)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_Call::IsInitialized() const {
+  return true;
+}
+
+void Message_Call::InternalSwap(Message_Call* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.callkey_, lhs_arena,
+      &other->_impl_.callkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.conversionsource_, lhs_arena,
+      &other->_impl_.conversionsource_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.conversiondata_, lhs_arena,
+      &other->_impl_.conversiondata_, rhs_arena
+  );
+  swap(_impl_.conversiondelayseconds_, other->_impl_.conversiondelayseconds_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_Call::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[66]);
+}
+
+// ===================================================================
+
+class Message_CancelPaymentRequestMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_CancelPaymentRequestMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Message_CancelPaymentRequestMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_CancelPaymentRequestMessage::_Internal::key(const Message_CancelPaymentRequestMessage* msg) {
+  return *msg->_impl_.key_;
+}
+Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.CancelPaymentRequestMessage)
+}
+Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_CancelPaymentRequestMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.CancelPaymentRequestMessage)
+}
+
+inline void Message_CancelPaymentRequestMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+  };
+}
+
+Message_CancelPaymentRequestMessage::~Message_CancelPaymentRequestMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.CancelPaymentRequestMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_CancelPaymentRequestMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void Message_CancelPaymentRequestMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_CancelPaymentRequestMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.CancelPaymentRequestMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.key_ != nullptr);
+    _impl_.key_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_CancelPaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_CancelPaymentRequestMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.CancelPaymentRequestMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.CancelPaymentRequestMessage)
+  return target;
+}
+
+size_t Message_CancelPaymentRequestMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.CancelPaymentRequestMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.MessageKey key = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.key_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_CancelPaymentRequestMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_CancelPaymentRequestMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_CancelPaymentRequestMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_CancelPaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_CancelPaymentRequestMessage*>(&to_msg);
+  auto& from = static_cast<const Message_CancelPaymentRequestMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.CancelPaymentRequestMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+        from._internal_key());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_CancelPaymentRequestMessage::CopyFrom(const Message_CancelPaymentRequestMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.CancelPaymentRequestMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_CancelPaymentRequestMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_CancelPaymentRequestMessage::InternalSwap(Message_CancelPaymentRequestMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.key_, other->_impl_.key_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_CancelPaymentRequestMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[67]);
+}
+
+// ===================================================================
+
+class Message_Chat::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_Chat>()._impl_._has_bits_);
+  static void set_has_displayname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_Chat::Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.Chat)
+}
+Message_Chat::Message_Chat(const Message_Chat& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_Chat* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displayname()) {
+    _this->_impl_.displayname_.Set(from._internal_displayname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.Chat)
+}
+
+inline void Message_Chat::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.id_){}
+  };
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_Chat::~Message_Chat() {
+  // @@protoc_insertion_point(destructor:proto.Message.Chat)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_Chat::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displayname_.Destroy();
+  _impl_.id_.Destroy();
+}
+
+void Message_Chat::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_Chat::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.Chat)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displayname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_Chat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displayname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.Chat.displayName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.Chat.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_Chat::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Chat)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displayname().data(), static_cast<int>(this->_internal_displayname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.Chat.displayName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displayname(), target);
+  }
+
+  // optional string id = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.Chat.id");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.Chat)
+  return target;
+}
+
+size_t Message_Chat::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.Chat)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string displayName = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displayname());
+    }
+
+    // optional string id = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Chat::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_Chat::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Chat::GetClassData() const { return &_class_data_; }
+
+
+void Message_Chat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_Chat*>(&to_msg);
+  auto& from = static_cast<const Message_Chat&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Chat)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displayname(from._internal_displayname());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_Chat::CopyFrom(const Message_Chat& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Chat)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_Chat::IsInitialized() const {
+  return true;
+}
+
+void Message_Chat::InternalSwap(Message_Chat* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displayname_, lhs_arena,
+      &other->_impl_.displayname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_Chat::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[68]);
+}
+
+// ===================================================================
+
+class Message_ContactMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ContactMessage>()._impl_._has_bits_);
+  static void set_has_displayname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_vcard(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ContactMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_ContactMessage::_Internal::contextinfo(const Message_ContactMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ContactMessage::Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ContactMessage)
+}
+Message_ContactMessage::Message_ContactMessage(const Message_ContactMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ContactMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.vcard_){}
+    , decltype(_impl_.contextinfo_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displayname()) {
+    _this->_impl_.displayname_.Set(from._internal_displayname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.vcard_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.vcard_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_vcard()) {
+    _this->_impl_.vcard_.Set(from._internal_vcard(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ContactMessage)
+}
+
+inline void Message_ContactMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.vcard_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+  };
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.vcard_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.vcard_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ContactMessage::~Message_ContactMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ContactMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ContactMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.displayname_.Destroy();
+  _impl_.vcard_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ContactMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ContactMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ContactMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displayname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.vcard_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ContactMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displayname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.displayName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string vcard = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_vcard();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.vcard");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ContactMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displayname().data(), static_cast<int>(this->_internal_displayname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ContactMessage.displayName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displayname(), target);
+  }
+
+  // optional string vcard = 16;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_vcard().data(), static_cast<int>(this->_internal_vcard().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ContactMessage.vcard");
+    target = stream->WriteStringMaybeAliased(
+        16, this->_internal_vcard(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ContactMessage)
+  return target;
+}
+
+size_t Message_ContactMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string displayName = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displayname());
+    }
+
+    // optional string vcard = 16;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_vcard());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ContactMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ContactMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ContactMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ContactMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displayname(from._internal_displayname());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_vcard(from._internal_vcard());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ContactMessage::CopyFrom(const Message_ContactMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ContactMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ContactMessage::InternalSwap(Message_ContactMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displayname_, lhs_arena,
+      &other->_impl_.displayname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.vcard_, lhs_arena,
+      &other->_impl_.vcard_, rhs_arena
+  );
+  swap(_impl_.contextinfo_, other->_impl_.contextinfo_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[69]);
+}
+
+// ===================================================================
+
+class Message_ContactsArrayMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ContactsArrayMessage>()._impl_._has_bits_);
+  static void set_has_displayname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ContactsArrayMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_ContactsArrayMessage::_Internal::contextinfo(const Message_ContactsArrayMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ContactsArrayMessage::Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ContactsArrayMessage)
+}
+Message_ContactsArrayMessage::Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ContactsArrayMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contacts_){from._impl_.contacts_}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.contextinfo_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_displayname()) {
+    _this->_impl_.displayname_.Set(from._internal_displayname(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ContactsArrayMessage)
+}
+
+inline void Message_ContactsArrayMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contacts_){arena}
+    , decltype(_impl_.displayname_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+  };
+  _impl_.displayname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ContactsArrayMessage::~Message_ContactsArrayMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ContactsArrayMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ContactsArrayMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.contacts_.~RepeatedPtrField();
+  _impl_.displayname_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ContactsArrayMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ContactsArrayMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ContactsArrayMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.contacts_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.displayname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ContactsArrayMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string displayName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_displayname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ContactsArrayMessage.displayName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.ContactMessage contacts = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_contacts(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ContactsArrayMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactsArrayMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string displayName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_displayname().data(), static_cast<int>(this->_internal_displayname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ContactsArrayMessage.displayName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_displayname(), target);
+  }
+
+  // repeated .proto.Message.ContactMessage contacts = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_contacts_size()); i < n; i++) {
+    const auto& repfield = this->_internal_contacts(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ContactsArrayMessage)
+  return target;
+}
+
+size_t Message_ContactsArrayMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactsArrayMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ContactMessage contacts = 2;
+  total_size += 1UL * this->_internal_contacts_size();
+  for (const auto& msg : this->_impl_.contacts_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string displayName = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_displayname());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactsArrayMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ContactsArrayMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactsArrayMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ContactsArrayMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ContactsArrayMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ContactsArrayMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactsArrayMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.contacts_.MergeFrom(from._impl_.contacts_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_displayname(from._internal_displayname());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ContactsArrayMessage::CopyFrom(const Message_ContactsArrayMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactsArrayMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ContactsArrayMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ContactsArrayMessage::InternalSwap(Message_ContactsArrayMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.contacts_.InternalSwap(&other->_impl_.contacts_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.displayname_, lhs_arena,
+      &other->_impl_.displayname_, rhs_arena
+  );
+  swap(_impl_.contextinfo_, other->_impl_.contextinfo_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactsArrayMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[70]);
+}
+
+// ===================================================================
+
+class Message_DeclinePaymentRequestMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_DeclinePaymentRequestMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Message_DeclinePaymentRequestMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_DeclinePaymentRequestMessage::_Internal::key(const Message_DeclinePaymentRequestMessage* msg) {
+  return *msg->_impl_.key_;
+}
+Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.DeclinePaymentRequestMessage)
+}
+Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_DeclinePaymentRequestMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.DeclinePaymentRequestMessage)
+}
+
+inline void Message_DeclinePaymentRequestMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+  };
+}
+
+Message_DeclinePaymentRequestMessage::~Message_DeclinePaymentRequestMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.DeclinePaymentRequestMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_DeclinePaymentRequestMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void Message_DeclinePaymentRequestMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_DeclinePaymentRequestMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.DeclinePaymentRequestMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.key_ != nullptr);
+    _impl_.key_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_DeclinePaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_DeclinePaymentRequestMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeclinePaymentRequestMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.DeclinePaymentRequestMessage)
+  return target;
+}
+
+size_t Message_DeclinePaymentRequestMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeclinePaymentRequestMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.MessageKey key = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.key_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeclinePaymentRequestMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_DeclinePaymentRequestMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeclinePaymentRequestMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_DeclinePaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_DeclinePaymentRequestMessage*>(&to_msg);
+  auto& from = static_cast<const Message_DeclinePaymentRequestMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeclinePaymentRequestMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+        from._internal_key());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_DeclinePaymentRequestMessage::CopyFrom(const Message_DeclinePaymentRequestMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeclinePaymentRequestMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_DeclinePaymentRequestMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_DeclinePaymentRequestMessage::InternalSwap(Message_DeclinePaymentRequestMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.key_, other->_impl_.key_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_DeclinePaymentRequestMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[71]);
+}
+
+// ===================================================================
+
+class Message_DeviceSentMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_DeviceSentMessage>()._impl_._has_bits_);
+  static void set_has_destinationjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message& message(const Message_DeviceSentMessage* msg);
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_phash(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message&
+Message_DeviceSentMessage::_Internal::message(const Message_DeviceSentMessage* msg) {
+  return *msg->_impl_.message_;
+}
+Message_DeviceSentMessage::Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.DeviceSentMessage)
+}
+Message_DeviceSentMessage::Message_DeviceSentMessage(const Message_DeviceSentMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_DeviceSentMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.destinationjid_){}
+    , decltype(_impl_.phash_){}
+    , decltype(_impl_.message_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.destinationjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.destinationjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_destinationjid()) {
+    _this->_impl_.destinationjid_.Set(from._internal_destinationjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.phash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_phash()) {
+    _this->_impl_.phash_.Set(from._internal_phash(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_message()) {
+    _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.DeviceSentMessage)
+}
+
+inline void Message_DeviceSentMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.destinationjid_){}
+    , decltype(_impl_.phash_){}
+    , decltype(_impl_.message_){nullptr}
+  };
+  _impl_.destinationjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.destinationjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.phash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_DeviceSentMessage::~Message_DeviceSentMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.DeviceSentMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_DeviceSentMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.destinationjid_.Destroy();
+  _impl_.phash_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.message_;
+}
+
+void Message_DeviceSentMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_DeviceSentMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.DeviceSentMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.destinationjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.phash_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.message_ != nullptr);
+      _impl_.message_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_DeviceSentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string destinationJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_destinationjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.destinationJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_message(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string phash = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_phash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.phash");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_DeviceSentMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeviceSentMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string destinationJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_destinationjid().data(), static_cast<int>(this->_internal_destinationjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DeviceSentMessage.destinationJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_destinationjid(), target);
+  }
+
+  // optional .proto.Message message = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::message(this),
+        _Internal::message(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string phash = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_phash().data(), static_cast<int>(this->_internal_phash().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DeviceSentMessage.phash");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_phash(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.DeviceSentMessage)
+  return target;
+}
+
+size_t Message_DeviceSentMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeviceSentMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string destinationJid = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_destinationjid());
+    }
+
+    // optional string phash = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_phash());
+    }
+
+    // optional .proto.Message message = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.message_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeviceSentMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_DeviceSentMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeviceSentMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_DeviceSentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_DeviceSentMessage*>(&to_msg);
+  auto& from = static_cast<const Message_DeviceSentMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeviceSentMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_destinationjid(from._internal_destinationjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_phash(from._internal_phash());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_message()->::proto::Message::MergeFrom(
+          from._internal_message());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_DeviceSentMessage::CopyFrom(const Message_DeviceSentMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeviceSentMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_DeviceSentMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_DeviceSentMessage::InternalSwap(Message_DeviceSentMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.destinationjid_, lhs_arena,
+      &other->_impl_.destinationjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.phash_, lhs_arena,
+      &other->_impl_.phash_, rhs_arena
+  );
+  swap(_impl_.message_, other->_impl_.message_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_DeviceSentMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[72]);
+}
+
+// ===================================================================
+
+class Message_DocumentMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_DocumentMessage>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_pagecount(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_filename(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_contactvcard(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_thumbnaildirectpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_thumbnailsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_thumbnailencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_DocumentMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_thumbnailheight(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_thumbnailwidth(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_DocumentMessage::_Internal::contextinfo(const Message_DocumentMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_DocumentMessage::Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.DocumentMessage)
+}
+Message_DocumentMessage::Message_DocumentMessage(const Message_DocumentMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_DocumentMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.filename_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.pagecount_){}
+    , decltype(_impl_.contactvcard_){}
+    , decltype(_impl_.mediakeytimestamp_){}
+    , decltype(_impl_.thumbnailheight_){}
+    , decltype(_impl_.thumbnailwidth_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filename()) {
+    _this->_impl_.filename_.Set(from._internal_filename(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnaildirectpath()) {
+    _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailsha256()) {
+    _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailencsha256()) {
+    _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.thumbnailwidth_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.thumbnailwidth_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.DocumentMessage)
+}
+
+inline void Message_DocumentMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.filename_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.pagecount_){0u}
+    , decltype(_impl_.contactvcard_){false}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.thumbnailheight_){0u}
+    , decltype(_impl_.thumbnailwidth_){0u}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_DocumentMessage::~Message_DocumentMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.DocumentMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_DocumentMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.title_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.filename_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.thumbnaildirectpath_.Destroy();
+  _impl_.thumbnailsha256_.Destroy();
+  _impl_.thumbnailencsha256_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.caption_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_DocumentMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_DocumentMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.DocumentMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.filename_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.thumbnailsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000c000u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.pagecount_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.pagecount_));
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    ::memset(&_impl_.contactvcard_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.thumbnailwidth_) -
+        reinterpret_cast<char*>(&_impl_.contactvcard_)) + sizeof(_impl_.thumbnailwidth_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_DocumentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string title = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 pageCount = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_pagecount(&has_bits);
+          _impl_.pagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string fileName = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_filename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.fileName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool contactVcard = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_contactvcard(&has_bits);
+          _impl_.contactvcard_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string thumbnailDirectPath = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_thumbnaildirectpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.thumbnailDirectPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailSha256 = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          auto str = _internal_mutable_thumbnailsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailEncSha256 = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          auto str = _internal_mutable_thumbnailencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 thumbnailHeight = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_thumbnailheight(&has_bits);
+          _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 thumbnailWidth = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
+          _Internal::set_has_thumbnailwidth(&has_bits);
+          _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_DocumentMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DocumentMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string mimetype = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_mimetype(), target);
+  }
+
+  // optional string title = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.title");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_title(), target);
+  }
+
+  // optional bytes fileSha256 = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_filesha256(), target);
+  }
+
+  // optional uint64 fileLength = 5;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target);
+  }
+
+  // optional uint32 pageCount = 6;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pagecount(), target);
+  }
+
+  // optional bytes mediaKey = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        7, this->_internal_mediakey(), target);
+  }
+
+  // optional string fileName = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_filename().data(), static_cast<int>(this->_internal_filename().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.fileName");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_filename(), target);
+  }
+
+  // optional bytes fileEncSha256 = 9;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        9, this->_internal_fileencsha256(), target);
+  }
+
+  // optional string directPath = 10;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.directPath");
+    target = stream->WriteStringMaybeAliased(
+        10, this->_internal_directpath(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 11;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional bool contactVcard = 12;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_contactvcard(), target);
+  }
+
+  // optional string thumbnailDirectPath = 13;
+  if (cached_has_bits & 0x00000100u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_thumbnaildirectpath().data(), static_cast<int>(this->_internal_thumbnaildirectpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.thumbnailDirectPath");
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_thumbnaildirectpath(), target);
+  }
+
+  // optional bytes thumbnailSha256 = 14;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->WriteBytesMaybeAliased(
+        14, this->_internal_thumbnailsha256(), target);
+  }
+
+  // optional bytes thumbnailEncSha256 = 15;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->WriteBytesMaybeAliased(
+        15, this->_internal_thumbnailencsha256(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 thumbnailHeight = 18;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_thumbnailheight(), target);
+  }
+
+  // optional uint32 thumbnailWidth = 19;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_thumbnailwidth(), target);
+  }
+
+  // optional string caption = 20;
+  if (cached_has_bits & 0x00001000u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.DocumentMessage.caption");
+    target = stream->WriteStringMaybeAliased(
+        20, this->_internal_caption(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.DocumentMessage)
+  return target;
+}
+
+size_t Message_DocumentMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.DocumentMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string mimetype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional string title = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional bytes fileSha256 = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes mediaKey = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string fileName = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_filename());
+    }
+
+    // optional bytes fileEncSha256 = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 10;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional string thumbnailDirectPath = 13;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_thumbnaildirectpath());
+    }
+
+    // optional bytes thumbnailSha256 = 14;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailsha256());
+    }
+
+    // optional bytes thumbnailEncSha256 = 15;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailencsha256());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional string caption = 20;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint64 fileLength = 5;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional uint32 pageCount = 6;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pagecount());
+    }
+
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    // optional bool contactVcard = 12;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional int64 mediaKeyTimestamp = 11;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+    // optional uint32 thumbnailHeight = 18;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_thumbnailheight());
+    }
+
+    // optional uint32 thumbnailWidth = 19;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_thumbnailwidth());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DocumentMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_DocumentMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DocumentMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_DocumentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_DocumentMessage*>(&to_msg);
+  auto& from = static_cast<const Message_DocumentMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DocumentMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_filename(from._internal_filename());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.pagecount_ = from._impl_.pagecount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.contactvcard_ = from._impl_.contactvcard_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_DocumentMessage::CopyFrom(const Message_DocumentMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DocumentMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_DocumentMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_DocumentMessage::InternalSwap(Message_DocumentMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filename_, lhs_arena,
+      &other->_impl_.filename_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnaildirectpath_, lhs_arena,
+      &other->_impl_.thumbnaildirectpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailsha256_, lhs_arena,
+      &other->_impl_.thumbnailsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailencsha256_, lhs_arena,
+      &other->_impl_.thumbnailencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.thumbnailwidth_)
+      + sizeof(Message_DocumentMessage::_impl_.thumbnailwidth_)
+      - PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_DocumentMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[73]);
+}
+
+// ===================================================================
+
+class Message_ExtendedTextMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ExtendedTextMessage>()._impl_._has_bits_);
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_matchedtext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_canonicalurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_textargb(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_backgroundargb(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_font(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_previewtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ExtendedTextMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_donotplayinline(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_thumbnaildirectpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_thumbnailsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_thumbnailencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_thumbnailheight(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_thumbnailwidth(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_invitelinkgrouptype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_invitelinkparentgroupsubjectv2(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_invitelinkparentgroupthumbnailv2(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_invitelinkgrouptypev2(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_ExtendedTextMessage::_Internal::contextinfo(const Message_ExtendedTextMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ExtendedTextMessage::Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ExtendedTextMessage)
+}
+Message_ExtendedTextMessage::Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ExtendedTextMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.matchedtext_){}
+    , decltype(_impl_.canonicalurl_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.invitelinkparentgroupsubjectv2_){}
+    , decltype(_impl_.invitelinkparentgroupthumbnailv2_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.textargb_){}
+    , decltype(_impl_.backgroundargb_){}
+    , decltype(_impl_.font_){}
+    , decltype(_impl_.previewtype_){}
+    , decltype(_impl_.donotplayinline_){}
+    , decltype(_impl_.thumbnailheight_){}
+    , decltype(_impl_.mediakeytimestamp_){}
+    , decltype(_impl_.thumbnailwidth_){}
+    , decltype(_impl_.invitelinkgrouptype_){}
+    , decltype(_impl_.invitelinkgrouptypev2_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.matchedtext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_matchedtext()) {
+    _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.canonicalurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_canonicalurl()) {
+    _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnaildirectpath()) {
+    _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailsha256()) {
+    _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailencsha256()) {
+    _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.invitelinkparentgroupsubjectv2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_invitelinkparentgroupsubjectv2()) {
+    _this->_impl_.invitelinkparentgroupsubjectv2_.Set(from._internal_invitelinkparentgroupsubjectv2(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.invitelinkparentgroupthumbnailv2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_invitelinkparentgroupthumbnailv2()) {
+    _this->_impl_.invitelinkparentgroupthumbnailv2_.Set(from._internal_invitelinkparentgroupthumbnailv2(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.textargb_, &from._impl_.textargb_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.invitelinkgrouptypev2_) -
+    reinterpret_cast<char*>(&_impl_.textargb_)) + sizeof(_impl_.invitelinkgrouptypev2_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ExtendedTextMessage)
+}
+
+inline void Message_ExtendedTextMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.matchedtext_){}
+    , decltype(_impl_.canonicalurl_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.invitelinkparentgroupsubjectv2_){}
+    , decltype(_impl_.invitelinkparentgroupthumbnailv2_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.textargb_){0u}
+    , decltype(_impl_.backgroundargb_){0u}
+    , decltype(_impl_.font_){0}
+    , decltype(_impl_.previewtype_){0}
+    , decltype(_impl_.donotplayinline_){false}
+    , decltype(_impl_.thumbnailheight_){0u}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.thumbnailwidth_){0u}
+    , decltype(_impl_.invitelinkgrouptype_){0}
+    , decltype(_impl_.invitelinkgrouptypev2_){0}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.matchedtext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.canonicalurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.invitelinkparentgroupsubjectv2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.invitelinkparentgroupthumbnailv2_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ExtendedTextMessage::~Message_ExtendedTextMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ExtendedTextMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ExtendedTextMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+  _impl_.matchedtext_.Destroy();
+  _impl_.canonicalurl_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.title_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.thumbnaildirectpath_.Destroy();
+  _impl_.thumbnailsha256_.Destroy();
+  _impl_.thumbnailencsha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.invitelinkparentgroupsubjectv2_.Destroy();
+  _impl_.invitelinkparentgroupthumbnailv2_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ExtendedTextMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ExtendedTextMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ExtendedTextMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.text_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.matchedtext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.canonicalurl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.thumbnailsha256_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.invitelinkparentgroupsubjectv2_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.invitelinkparentgroupthumbnailv2_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000e000u) {
+    ::memset(&_impl_.textargb_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.font_) -
+        reinterpret_cast<char*>(&_impl_.textargb_)) + sizeof(_impl_.font_));
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    ::memset(&_impl_.previewtype_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.invitelinkgrouptypev2_) -
+        reinterpret_cast<char*>(&_impl_.previewtype_)) + sizeof(_impl_.invitelinkgrouptypev2_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ExtendedTextMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string text = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string matchedText = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_matchedtext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.matchedText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string canonicalUrl = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_canonicalurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.canonicalUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string title = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed32 textArgb = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 61)) {
+          _Internal::set_has_textargb(&has_bits);
+          _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
+          ptr += sizeof(uint32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed32 backgroundArgb = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
+          _Internal::set_has_backgroundargb(&has_bits);
+          _impl_.backgroundargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
+          ptr += sizeof(uint32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ExtendedTextMessage.FontType font = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_FontType_IsValid(val))) {
+            _internal_set_font(static_cast<::proto::Message_ExtendedTextMessage_FontType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(val))) {
+            _internal_set_previewtype(static_cast<::proto::Message_ExtendedTextMessage_PreviewType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool doNotPlayInline = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_donotplayinline(&has_bits);
+          _impl_.donotplayinline_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string thumbnailDirectPath = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_thumbnaildirectpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.thumbnailDirectPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailSha256 = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          auto str = _internal_mutable_thumbnailsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailEncSha256 = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_thumbnailencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 thumbnailHeight = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
+          _Internal::set_has_thumbnailheight(&has_bits);
+          _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 thumbnailWidth = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          _Internal::set_has_thumbnailwidth(&has_bits);
+          _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) {
+            _internal_set_invitelinkgrouptype(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string inviteLinkParentGroupSubjectV2 = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          auto str = _internal_mutable_invitelinkparentgroupsubjectv2();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          auto str = _internal_mutable_invitelinkparentgroupthumbnailv2();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) {
+            _internal_set_invitelinkgrouptypev2(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ExtendedTextMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ExtendedTextMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string text = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.text");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_text(), target);
+  }
+
+  // optional string matchedText = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_matchedtext().data(), static_cast<int>(this->_internal_matchedtext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.matchedText");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_matchedtext(), target);
+  }
+
+  // optional string canonicalUrl = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_canonicalurl().data(), static_cast<int>(this->_internal_canonicalurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.canonicalUrl");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_canonicalurl(), target);
+  }
+
+  // optional string description = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.description");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_description(), target);
+  }
+
+  // optional string title = 6;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.title");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_title(), target);
+  }
+
+  // optional fixed32 textArgb = 7;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target);
+  }
+
+  // optional fixed32 backgroundArgb = 8;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_backgroundargb(), target);
+  }
+
+  // optional .proto.Message.ExtendedTextMessage.FontType font = 9;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      9, this->_internal_font(), target);
+  }
+
+  // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_previewtype(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool doNotPlayInline = 18;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_donotplayinline(), target);
+  }
+
+  // optional string thumbnailDirectPath = 19;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_thumbnaildirectpath().data(), static_cast<int>(this->_internal_thumbnaildirectpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.thumbnailDirectPath");
+    target = stream->WriteStringMaybeAliased(
+        19, this->_internal_thumbnaildirectpath(), target);
+  }
+
+  // optional bytes thumbnailSha256 = 20;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        20, this->_internal_thumbnailsha256(), target);
+  }
+
+  // optional bytes thumbnailEncSha256 = 21;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->WriteBytesMaybeAliased(
+        21, this->_internal_thumbnailencsha256(), target);
+  }
+
+  // optional bytes mediaKey = 22;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->WriteBytesMaybeAliased(
+        22, this->_internal_mediakey(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 23;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(23, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional uint32 thumbnailHeight = 24;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_thumbnailheight(), target);
+  }
+
+  // optional uint32 thumbnailWidth = 25;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_thumbnailwidth(), target);
+  }
+
+  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      26, this->_internal_invitelinkgrouptype(), target);
+  }
+
+  // optional string inviteLinkParentGroupSubjectV2 = 27;
+  if (cached_has_bits & 0x00000400u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_invitelinkparentgroupsubjectv2().data(), static_cast<int>(this->_internal_invitelinkparentgroupsubjectv2().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2");
+    target = stream->WriteStringMaybeAliased(
+        27, this->_internal_invitelinkparentgroupsubjectv2(), target);
+  }
+
+  // optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->WriteBytesMaybeAliased(
+        28, this->_internal_invitelinkparentgroupthumbnailv2(), target);
+  }
+
+  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      29, this->_internal_invitelinkgrouptypev2(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ExtendedTextMessage)
+  return target;
+}
+
+size_t Message_ExtendedTextMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ExtendedTextMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string text = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_text());
+    }
+
+    // optional string matchedText = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_matchedtext());
+    }
+
+    // optional string canonicalUrl = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_canonicalurl());
+    }
+
+    // optional string description = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string title = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional string thumbnailDirectPath = 19;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_thumbnaildirectpath());
+    }
+
+    // optional bytes thumbnailSha256 = 20;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailsha256());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional bytes thumbnailEncSha256 = 21;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailencsha256());
+    }
+
+    // optional bytes mediaKey = 22;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string inviteLinkParentGroupSubjectV2 = 27;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_invitelinkparentgroupsubjectv2());
+    }
+
+    // optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_invitelinkparentgroupthumbnailv2());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional fixed32 textArgb = 7;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 backgroundArgb = 8;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 + 4;
+    }
+
+    // optional .proto.Message.ExtendedTextMessage.FontType font = 9;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_font());
+    }
+
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_previewtype());
+    }
+
+    // optional bool doNotPlayInline = 18;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint32 thumbnailHeight = 24;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_thumbnailheight());
+    }
+
+    // optional int64 mediaKeyTimestamp = 23;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int64Size(
+          this->_internal_mediakeytimestamp());
+    }
+
+    // optional uint32 thumbnailWidth = 25;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_thumbnailwidth());
+    }
+
+    // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptype());
+    }
+
+    // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptypev2());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ExtendedTextMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ExtendedTextMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ExtendedTextMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ExtendedTextMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ExtendedTextMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ExtendedTextMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ExtendedTextMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_text(from._internal_text());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_matchedtext(from._internal_matchedtext());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_canonicalurl(from._internal_canonicalurl());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_invitelinkparentgroupsubjectv2(from._internal_invitelinkparentgroupsubjectv2());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_invitelinkparentgroupthumbnailv2(from._internal_invitelinkparentgroupthumbnailv2());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.textargb_ = from._impl_.textargb_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.backgroundargb_ = from._impl_.backgroundargb_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.font_ = from._impl_.font_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x007f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.previewtype_ = from._impl_.previewtype_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.donotplayinline_ = from._impl_.donotplayinline_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.invitelinkgrouptype_ = from._impl_.invitelinkgrouptype_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.invitelinkgrouptypev2_ = from._impl_.invitelinkgrouptypev2_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ExtendedTextMessage::CopyFrom(const Message_ExtendedTextMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ExtendedTextMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ExtendedTextMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ExtendedTextMessage::InternalSwap(Message_ExtendedTextMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.matchedtext_, lhs_arena,
+      &other->_impl_.matchedtext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.canonicalurl_, lhs_arena,
+      &other->_impl_.canonicalurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnaildirectpath_, lhs_arena,
+      &other->_impl_.thumbnaildirectpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailsha256_, lhs_arena,
+      &other->_impl_.thumbnailsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailencsha256_, lhs_arena,
+      &other->_impl_.thumbnailencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.invitelinkparentgroupsubjectv2_, lhs_arena,
+      &other->_impl_.invitelinkparentgroupsubjectv2_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.invitelinkparentgroupthumbnailv2_, lhs_arena,
+      &other->_impl_.invitelinkparentgroupthumbnailv2_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_)
+      + sizeof(Message_ExtendedTextMessage::_impl_.invitelinkgrouptypev2_)
+      - PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ExtendedTextMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[74]);
+}
+
+// ===================================================================
+
+class Message_FutureProofMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_FutureProofMessage>()._impl_._has_bits_);
+  static const ::proto::Message& message(const Message_FutureProofMessage* msg);
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::Message&
+Message_FutureProofMessage::_Internal::message(const Message_FutureProofMessage* msg) {
+  return *msg->_impl_.message_;
+}
+Message_FutureProofMessage::Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.FutureProofMessage)
+}
+Message_FutureProofMessage::Message_FutureProofMessage(const Message_FutureProofMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_FutureProofMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_message()) {
+    _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.FutureProofMessage)
+}
+
+inline void Message_FutureProofMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){nullptr}
+  };
+}
+
+Message_FutureProofMessage::~Message_FutureProofMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.FutureProofMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_FutureProofMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.message_;
+}
+
+void Message_FutureProofMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_FutureProofMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.FutureProofMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.message_ != nullptr);
+    _impl_.message_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_FutureProofMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message message = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_message(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_FutureProofMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.FutureProofMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message message = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::message(this),
+        _Internal::message(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.FutureProofMessage)
+  return target;
+}
+
+size_t Message_FutureProofMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.FutureProofMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.Message message = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.message_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_FutureProofMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_FutureProofMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_FutureProofMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_FutureProofMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_FutureProofMessage*>(&to_msg);
+  auto& from = static_cast<const Message_FutureProofMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.FutureProofMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_message()) {
+    _this->_internal_mutable_message()->::proto::Message::MergeFrom(
+        from._internal_message());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_FutureProofMessage::CopyFrom(const Message_FutureProofMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.FutureProofMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_FutureProofMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_FutureProofMessage::InternalSwap(Message_FutureProofMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.message_, other->_impl_.message_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_FutureProofMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[75]);
+}
+
+// ===================================================================
+
+class Message_GroupInviteMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_GroupInviteMessage>()._impl_._has_bits_);
+  static void set_has_groupjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_invitecode(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_inviteexpiration(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_groupname(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_GroupInviteMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_grouptype(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_GroupInviteMessage::_Internal::contextinfo(const Message_GroupInviteMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_GroupInviteMessage::Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.GroupInviteMessage)
+}
+Message_GroupInviteMessage::Message_GroupInviteMessage(const Message_GroupInviteMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_GroupInviteMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.groupjid_){}
+    , decltype(_impl_.invitecode_){}
+    , decltype(_impl_.groupname_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.inviteexpiration_){}
+    , decltype(_impl_.grouptype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.groupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupjid()) {
+    _this->_impl_.groupjid_.Set(from._internal_groupjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.invitecode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitecode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_invitecode()) {
+    _this->_impl_.invitecode_.Set(from._internal_invitecode(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.groupname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupname()) {
+    _this->_impl_.groupname_.Set(from._internal_groupname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.inviteexpiration_, &from._impl_.inviteexpiration_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.grouptype_) -
+    reinterpret_cast<char*>(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.GroupInviteMessage)
+}
+
+inline void Message_GroupInviteMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.groupjid_){}
+    , decltype(_impl_.invitecode_){}
+    , decltype(_impl_.groupname_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.inviteexpiration_){int64_t{0}}
+    , decltype(_impl_.grouptype_){0}
+  };
+  _impl_.groupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.invitecode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.invitecode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.groupname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_GroupInviteMessage::~Message_GroupInviteMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.GroupInviteMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_GroupInviteMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.groupjid_.Destroy();
+  _impl_.invitecode_.Destroy();
+  _impl_.groupname_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.caption_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_GroupInviteMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_GroupInviteMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.GroupInviteMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.groupjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.invitecode_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.groupname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    ::memset(&_impl_.inviteexpiration_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.grouptype_) -
+        reinterpret_cast<char*>(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_GroupInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string groupJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_groupjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string inviteCode = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_invitecode();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.inviteCode");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 inviteExpiration = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_inviteexpiration(&has_bits);
+          _impl_.inviteexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string groupName = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_groupname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_GroupInviteMessage_GroupType_IsValid(val))) {
+            _internal_set_grouptype(static_cast<::proto::Message_GroupInviteMessage_GroupType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_GroupInviteMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.GroupInviteMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string groupJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupjid().data(), static_cast<int>(this->_internal_groupjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.GroupInviteMessage.groupJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_groupjid(), target);
+  }
+
+  // optional string inviteCode = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_invitecode().data(), static_cast<int>(this->_internal_invitecode().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.GroupInviteMessage.inviteCode");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_invitecode(), target);
+  }
+
+  // optional int64 inviteExpiration = 3;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_inviteexpiration(), target);
+  }
+
+  // optional string groupName = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupname().data(), static_cast<int>(this->_internal_groupname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.GroupInviteMessage.groupName");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_groupname(), target);
+  }
+
+  // optional bytes jpegThumbnail = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional string caption = 6;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.GroupInviteMessage.caption");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_caption(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 7;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      8, this->_internal_grouptype(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.GroupInviteMessage)
+  return target;
+}
+
+size_t Message_GroupInviteMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.GroupInviteMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string groupJid = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupjid());
+    }
+
+    // optional string inviteCode = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_invitecode());
+    }
+
+    // optional string groupName = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupname());
+    }
+
+    // optional bytes jpegThumbnail = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional string caption = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 7;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional int64 inviteExpiration = 3;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_inviteexpiration());
+    }
+
+    // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_grouptype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_GroupInviteMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_GroupInviteMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_GroupInviteMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_GroupInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_GroupInviteMessage*>(&to_msg);
+  auto& from = static_cast<const Message_GroupInviteMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.GroupInviteMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_groupjid(from._internal_groupjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_invitecode(from._internal_invitecode());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_groupname(from._internal_groupname());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.inviteexpiration_ = from._impl_.inviteexpiration_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.grouptype_ = from._impl_.grouptype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_GroupInviteMessage::CopyFrom(const Message_GroupInviteMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.GroupInviteMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_GroupInviteMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_GroupInviteMessage::InternalSwap(Message_GroupInviteMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupjid_, lhs_arena,
+      &other->_impl_.groupjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.invitecode_, lhs_arena,
+      &other->_impl_.invitecode_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupname_, lhs_arena,
+      &other->_impl_.groupname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.grouptype_)
+      + sizeof(Message_GroupInviteMessage::_impl_.grouptype_)
+      - PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_GroupInviteMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[76]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>()._impl_._has_bits_);
+  static void set_has_currencycode(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_amount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.amount1000_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_currencycode()) {
+    _this->_impl_.currencycode_.Set(from._internal_currencycode(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.amount1000_ = from._impl_.amount1000_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.amount1000_){int64_t{0}}
+  };
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.currencycode_.Destroy();
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.currencycode_.ClearNonDefaultToEmpty();
+  }
+  _impl_.amount1000_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string currencyCode = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_currencycode();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 amount1000 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_amount1000(&has_bits);
+          _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string currencyCode = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_currencycode().data(), static_cast<int>(this->_internal_currencycode().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_currencycode(), target);
+  }
+
+  // optional int64 amount1000 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_amount1000(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string currencyCode = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_currencycode());
+    }
+
+    // optional int64 amount1000 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_amount1000());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_currencycode(from._internal_currencycode());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.amount1000_ = from._impl_.amount1000_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.currencycode_, lhs_arena,
+      &other->_impl_.currencycode_, rhs_arena
+  );
+  swap(_impl_.amount1000_, other->_impl_.amount1000_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[77]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>()._impl_._has_bits_);
+  static void set_has_dayofweek(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_year(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_month(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_dayofmonth(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_hour(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_minute(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_calendar(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+};
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.year_){}
+    , decltype(_impl_.month_){}
+    , decltype(_impl_.dayofmonth_){}
+    , decltype(_impl_.hour_){}
+    , decltype(_impl_.minute_){}
+    , decltype(_impl_.dayofweek_){}
+    , decltype(_impl_.calendar_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.year_, &from._impl_.year_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.calendar_) -
+    reinterpret_cast<char*>(&_impl_.year_)) + sizeof(_impl_.calendar_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.year_){0u}
+    , decltype(_impl_.month_){0u}
+    , decltype(_impl_.dayofmonth_){0u}
+    , decltype(_impl_.hour_){0u}
+    , decltype(_impl_.minute_){0u}
+    , decltype(_impl_.dayofweek_){1}
+    , decltype(_impl_.calendar_){1}
+  };
+}
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    ::memset(&_impl_.year_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.minute_) -
+        reinterpret_cast<char*>(&_impl_.year_)) + sizeof(_impl_.minute_));
+    _impl_.dayofweek_ = 1;
+    _impl_.calendar_ = 1;
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(val))) {
+            _internal_set_dayofweek(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 year = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_year(&has_bits);
+          _impl_.year_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 month = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_month(&has_bits);
+          _impl_.month_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 dayOfMonth = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_dayofmonth(&has_bits);
+          _impl_.dayofmonth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 hour = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_hour(&has_bits);
+          _impl_.hour_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 minute = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_minute(&has_bits);
+          _impl_.minute_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(val))) {
+            _internal_set_calendar(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_dayofweek(), target);
+  }
+
+  // optional uint32 year = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_year(), target);
+  }
+
+  // optional uint32 month = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_month(), target);
+  }
+
+  // optional uint32 dayOfMonth = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_dayofmonth(), target);
+  }
+
+  // optional uint32 hour = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_hour(), target);
+  }
+
+  // optional uint32 minute = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_minute(), target);
+  }
+
+  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      7, this->_internal_calendar(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional uint32 year = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_year());
+    }
+
+    // optional uint32 month = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_month());
+    }
+
+    // optional uint32 dayOfMonth = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dayofmonth());
+    }
+
+    // optional uint32 hour = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_hour());
+    }
+
+    // optional uint32 minute = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_minute());
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_dayofweek());
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_calendar());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.year_ = from._impl_.year_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.month_ = from._impl_.month_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.dayofmonth_ = from._impl_.dayofmonth_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.hour_ = from._impl_.hour_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.minute_ = from._impl_.minute_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.dayofweek_ = from._impl_.dayofweek_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.calendar_ = from._impl_.calendar_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_)
+      + sizeof(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_impl_.minute_)
+      - PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_)>(
+          reinterpret_cast<char*>(&_impl_.year_),
+          reinterpret_cast<char*>(&other->_impl_.year_));
+  swap(_impl_.dayofweek_, other->_impl_.dayofweek_);
+  swap(_impl_.calendar_, other->_impl_.calendar_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[78]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>()._impl_._has_bits_);
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.timestamp_ = from._impl_.timestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+  };
+}
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int64 timestamp = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 timestamp = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional int64 timestamp = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_timestamp()) {
+    _this->_internal_set_timestamp(from._internal_timestamp());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.timestamp_, other->_impl_.timestamp_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[79]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal {
+ public:
+  static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg);
+  static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg);
+};
+
+const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) {
+  return *msg->_impl_.datetimeOneof_.component_;
+}
+const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) {
+  return *msg->_impl_.datetimeOneof_.unixepoch_;
+}
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_datetimeOneof();
+  if (component) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(component);
+    if (message_arena != submessage_arena) {
+      component = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, component, submessage_arena);
+    }
+    set_has_component();
+    _impl_.datetimeOneof_.component_ = component;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+}
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_datetimeOneof();
+  if (unixepoch) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unixepoch);
+    if (message_arena != submessage_arena) {
+      unixepoch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, unixepoch, submessage_arena);
+    }
+    set_has_unixepoch();
+    _impl_.datetimeOneof_.unixepoch_ = unixepoch;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.datetimeOneof_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_datetimeOneof();
+  switch (from.datetimeOneof_case()) {
+    case kComponent: {
+      _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom(
+          from._internal_component());
+      break;
+    }
+    case kUnixEpoch: {
+      _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom(
+          from._internal_unixepoch());
+      break;
+    }
+    case DATETIMEONEOF_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.datetimeOneof_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_datetimeOneof();
+}
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_datetimeOneof()) {
+    clear_datetimeOneof();
+  }
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_datetimeOneof() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  switch (datetimeOneof_case()) {
+    case kComponent: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.datetimeOneof_.component_;
+      }
+      break;
+    }
+    case kUnixEpoch: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.datetimeOneof_.unixepoch_;
+      }
+      break;
+    }
+    case DATETIMEONEOF_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET;
+}
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_datetimeOneof();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_component(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_unixepoch(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (datetimeOneof_case()) {
+    case kComponent: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::component(this),
+          _Internal::component(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kUnixEpoch: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::unixepoch(this),
+          _Internal::unixepoch(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (datetimeOneof_case()) {
+    // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
+    case kComponent: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.datetimeOneof_.component_);
+      break;
+    }
+    // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
+    case kUnixEpoch: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.datetimeOneof_.unixepoch_);
+      break;
+    }
+    case DATETIMEONEOF_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.datetimeOneof_case()) {
+    case kComponent: {
+      _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom(
+          from._internal_component());
+      break;
+    }
+    case kUnixEpoch: {
+      _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom(
+          from._internal_unixepoch());
+      break;
+    }
+    case DATETIMEONEOF_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.datetimeOneof_, other->_impl_.datetimeOneof_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[80]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HighlyStructuredMessage_HSMLocalizableParameter>()._impl_._has_bits_);
+  static void set_has_default_(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg);
+  static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg);
+};
+
+const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&
+Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) {
+  return *msg->_impl_.paramOneof_.currency_;
+}
+const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&
+Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) {
+  return *msg->_impl_.paramOneof_.datetime_;
+}
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_paramOneof();
+  if (currency) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currency);
+    if (message_arena != submessage_arena) {
+      currency = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, currency, submessage_arena);
+    }
+    set_has_currency();
+    _impl_.paramOneof_.currency_ = currency;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+}
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_paramOneof();
+  if (datetime) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(datetime);
+    if (message_arena != submessage_arena) {
+      datetime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, datetime, submessage_arena);
+    }
+    set_has_datetime();
+    _impl_.paramOneof_.datetime_ = datetime;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+}
+Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.default__){}
+    , decltype(_impl_.paramOneof_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.default__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.default__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_default_()) {
+    _this->_impl_.default__.Set(from._internal_default_(), 
+      _this->GetArenaForAllocation());
+  }
+  clear_has_paramOneof();
+  switch (from.paramOneof_case()) {
+    case kCurrency: {
+      _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom(
+          from._internal_currency());
+      break;
+    }
+    case kDateTime: {
+      _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom(
+          from._internal_datetime());
+      break;
+    }
+    case PARAMONEOF_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.default__){}
+    , decltype(_impl_.paramOneof_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  _impl_.default__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.default__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  clear_has_paramOneof();
+}
+
+Message_HighlyStructuredMessage_HSMLocalizableParameter::~Message_HighlyStructuredMessage_HSMLocalizableParameter() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.default__.Destroy();
+  if (has_paramOneof()) {
+    clear_paramOneof();
+  }
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_paramOneof() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  switch (paramOneof_case()) {
+    case kCurrency: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.paramOneof_.currency_;
+      }
+      break;
+    }
+    case kDateTime: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.paramOneof_.datetime_;
+      }
+      break;
+    }
+    case PARAMONEOF_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET;
+}
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.default__.ClearNonDefaultToEmpty();
+  }
+  clear_paramOneof();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string default = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_default_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_currency(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_datetime(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string default = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_default_().data(), static_cast<int>(this->_internal_default_().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_default_(), target);
+  }
+
+  switch (paramOneof_case()) {
+    case kCurrency: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::currency(this),
+          _Internal::currency(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kDateTime: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::datetime(this),
+          _Internal::datetime(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage_HSMLocalizableParameter::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string default = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_default_());
+  }
+
+  switch (paramOneof_case()) {
+    // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
+    case kCurrency: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.paramOneof_.currency_);
+      break;
+    }
+    // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
+    case kDateTime: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.paramOneof_.datetime_);
+      break;
+    }
+    case PARAMONEOF_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage_HSMLocalizableParameter*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_default_()) {
+    _this->_internal_set_default_(from._internal_default_());
+  }
+  switch (from.paramOneof_case()) {
+    case kCurrency: {
+      _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom(
+          from._internal_currency());
+      break;
+    }
+    case kDateTime: {
+      _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom(
+          from._internal_datetime());
+      break;
+    }
+    case PARAMONEOF_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.default__, lhs_arena,
+      &other->_impl_.default__, rhs_arena
+  );
+  swap(_impl_.paramOneof_, other->_impl_.paramOneof_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[81]);
+}
+
+// ===================================================================
+
+class Message_HighlyStructuredMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HighlyStructuredMessage>()._impl_._has_bits_);
+  static void set_has_namespace_(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_elementname(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fallbacklg(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_fallbacklc(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_deterministiclg(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_deterministiclc(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::Message_TemplateMessage& hydratedhsm(const Message_HighlyStructuredMessage* msg);
+  static void set_has_hydratedhsm(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+};
+
+const ::proto::Message_TemplateMessage&
+Message_HighlyStructuredMessage::_Internal::hydratedhsm(const Message_HighlyStructuredMessage* msg) {
+  return *msg->_impl_.hydratedhsm_;
+}
+Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage)
+}
+Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HighlyStructuredMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.params_){from._impl_.params_}
+    , decltype(_impl_.localizableparams_){from._impl_.localizableparams_}
+    , decltype(_impl_.namespace__){}
+    , decltype(_impl_.elementname_){}
+    , decltype(_impl_.fallbacklg_){}
+    , decltype(_impl_.fallbacklc_){}
+    , decltype(_impl_.deterministiclg_){}
+    , decltype(_impl_.deterministiclc_){}
+    , decltype(_impl_.hydratedhsm_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.namespace__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.namespace__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_namespace_()) {
+    _this->_impl_.namespace__.Set(from._internal_namespace_(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.elementname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.elementname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_elementname()) {
+    _this->_impl_.elementname_.Set(from._internal_elementname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fallbacklg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fallbacklg()) {
+    _this->_impl_.fallbacklg_.Set(from._internal_fallbacklg(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fallbacklc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fallbacklc()) {
+    _this->_impl_.fallbacklc_.Set(from._internal_fallbacklc(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.deterministiclg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_deterministiclg()) {
+    _this->_impl_.deterministiclg_.Set(from._internal_deterministiclg(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.deterministiclc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_deterministiclc()) {
+    _this->_impl_.deterministiclc_.Set(from._internal_deterministiclc(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_hydratedhsm()) {
+    _this->_impl_.hydratedhsm_ = new ::proto::Message_TemplateMessage(*from._impl_.hydratedhsm_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage)
+}
+
+inline void Message_HighlyStructuredMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.params_){arena}
+    , decltype(_impl_.localizableparams_){arena}
+    , decltype(_impl_.namespace__){}
+    , decltype(_impl_.elementname_){}
+    , decltype(_impl_.fallbacklg_){}
+    , decltype(_impl_.fallbacklc_){}
+    , decltype(_impl_.deterministiclg_){}
+    , decltype(_impl_.deterministiclc_){}
+    , decltype(_impl_.hydratedhsm_){nullptr}
+  };
+  _impl_.namespace__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.namespace__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.elementname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.elementname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fallbacklg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fallbacklc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.deterministiclg_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.deterministiclc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_HighlyStructuredMessage::~Message_HighlyStructuredMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HighlyStructuredMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.params_.~RepeatedPtrField();
+  _impl_.localizableparams_.~RepeatedPtrField();
+  _impl_.namespace__.Destroy();
+  _impl_.elementname_.Destroy();
+  _impl_.fallbacklg_.Destroy();
+  _impl_.fallbacklc_.Destroy();
+  _impl_.deterministiclg_.Destroy();
+  _impl_.deterministiclc_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.hydratedhsm_;
+}
+
+void Message_HighlyStructuredMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HighlyStructuredMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.params_.Clear();
+  _impl_.localizableparams_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.namespace__.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.elementname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fallbacklg_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.fallbacklc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.deterministiclg_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.deterministiclc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.hydratedhsm_ != nullptr);
+      _impl_.hydratedhsm_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HighlyStructuredMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string namespace = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_namespace_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.namespace");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string elementName = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_elementname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.elementName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string params = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_params();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.params");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string fallbackLg = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_fallbacklg();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLg");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string fallbackLc = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_fallbacklc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_localizableparams(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string deterministicLg = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_deterministiclg();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLg");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string deterministicLc = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_deterministiclc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.TemplateMessage hydratedHsm = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_hydratedhsm(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HighlyStructuredMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string namespace = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_namespace_().data(), static_cast<int>(this->_internal_namespace_().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.namespace");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_namespace_(), target);
+  }
+
+  // optional string elementName = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_elementname().data(), static_cast<int>(this->_internal_elementname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.elementName");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_elementname(), target);
+  }
+
+  // repeated string params = 3;
+  for (int i = 0, n = this->_internal_params_size(); i < n; i++) {
+    const auto& s = this->_internal_params(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.params");
+    target = stream->WriteString(3, s, target);
+  }
+
+  // optional string fallbackLg = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_fallbacklg().data(), static_cast<int>(this->_internal_fallbacklg().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.fallbackLg");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_fallbacklg(), target);
+  }
+
+  // optional string fallbackLc = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_fallbacklc().data(), static_cast<int>(this->_internal_fallbacklc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.fallbackLc");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_fallbacklc(), target);
+  }
+
+  // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_localizableparams_size()); i < n; i++) {
+    const auto& repfield = this->_internal_localizableparams(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string deterministicLg = 7;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_deterministiclg().data(), static_cast<int>(this->_internal_deterministiclg().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.deterministicLg");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_deterministiclg(), target);
+  }
+
+  // optional string deterministicLc = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_deterministiclc().data(), static_cast<int>(this->_internal_deterministiclc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HighlyStructuredMessage.deterministicLc");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_deterministiclc(), target);
+  }
+
+  // optional .proto.Message.TemplateMessage hydratedHsm = 9;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::hydratedhsm(this),
+        _Internal::hydratedhsm(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HighlyStructuredMessage)
+  return target;
+}
+
+size_t Message_HighlyStructuredMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string params = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.params_.size());
+  for (int i = 0, n = _impl_.params_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.params_.Get(i));
+  }
+
+  // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
+  total_size += 1UL * this->_internal_localizableparams_size();
+  for (const auto& msg : this->_impl_.localizableparams_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional string namespace = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_namespace_());
+    }
+
+    // optional string elementName = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_elementname());
+    }
+
+    // optional string fallbackLg = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_fallbacklg());
+    }
+
+    // optional string fallbackLc = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_fallbacklc());
+    }
+
+    // optional string deterministicLg = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_deterministiclg());
+    }
+
+    // optional string deterministicLc = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_deterministiclc());
+    }
+
+    // optional .proto.Message.TemplateMessage hydratedHsm = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.hydratedhsm_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HighlyStructuredMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_HighlyStructuredMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HighlyStructuredMessage*>(&to_msg);
+  auto& from = static_cast<const Message_HighlyStructuredMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.params_.MergeFrom(from._impl_.params_);
+  _this->_impl_.localizableparams_.MergeFrom(from._impl_.localizableparams_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_namespace_(from._internal_namespace_());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_elementname(from._internal_elementname());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fallbacklg(from._internal_fallbacklg());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_fallbacklc(from._internal_fallbacklc());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_deterministiclg(from._internal_deterministiclg());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_deterministiclc(from._internal_deterministiclc());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_hydratedhsm()->::proto::Message_TemplateMessage::MergeFrom(
+          from._internal_hydratedhsm());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HighlyStructuredMessage::CopyFrom(const Message_HighlyStructuredMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HighlyStructuredMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_HighlyStructuredMessage::InternalSwap(Message_HighlyStructuredMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.params_.InternalSwap(&other->_impl_.params_);
+  _impl_.localizableparams_.InternalSwap(&other->_impl_.localizableparams_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.namespace__, lhs_arena,
+      &other->_impl_.namespace__, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.elementname_, lhs_arena,
+      &other->_impl_.elementname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fallbacklg_, lhs_arena,
+      &other->_impl_.fallbacklg_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fallbacklc_, lhs_arena,
+      &other->_impl_.fallbacklc_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.deterministiclg_, lhs_arena,
+      &other->_impl_.deterministiclg_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.deterministiclc_, lhs_arena,
+      &other->_impl_.deterministiclc_, rhs_arena
+  );
+  swap(_impl_.hydratedhsm_, other->_impl_.hydratedhsm_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[82]);
+}
+
+// ===================================================================
+
+class Message_HistorySyncNotification::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_HistorySyncNotification>()._impl_._has_bits_);
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_synctype(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_chunkorder(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_originalmessageid(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_progress(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+};
+
+Message_HistorySyncNotification::Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.HistorySyncNotification)
+}
+Message_HistorySyncNotification::Message_HistorySyncNotification(const Message_HistorySyncNotification& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_HistorySyncNotification* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.originalmessageid_){}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.synctype_){}
+    , decltype(_impl_.chunkorder_){}
+    , decltype(_impl_.progress_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.originalmessageid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_originalmessageid()) {
+    _this->_impl_.originalmessageid_.Set(from._internal_originalmessageid(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.progress_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.progress_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.HistorySyncNotification)
+}
+
+inline void Message_HistorySyncNotification::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.originalmessageid_){}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.synctype_){0}
+    , decltype(_impl_.chunkorder_){0u}
+    , decltype(_impl_.progress_){0u}
+  };
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.originalmessageid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_HistorySyncNotification::~Message_HistorySyncNotification() {
+  // @@protoc_insertion_point(destructor:proto.Message.HistorySyncNotification)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_HistorySyncNotification::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.filesha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.originalmessageid_.Destroy();
+}
+
+void Message_HistorySyncNotification::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_HistorySyncNotification::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.HistorySyncNotification)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.originalmessageid_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.chunkorder_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.chunkorder_));
+  }
+  _impl_.progress_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_HistorySyncNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes fileSha256 = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(val))) {
+            _internal_set_synctype(static_cast<::proto::Message_HistorySyncNotification_HistorySyncType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 chunkOrder = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_chunkorder(&has_bits);
+          _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string originalMessageId = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_originalmessageid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.originalMessageId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 progress = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_progress(&has_bits);
+          _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_HistorySyncNotification::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HistorySyncNotification)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes fileSha256 = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_filesha256(), target);
+  }
+
+  // optional uint64 fileLength = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target);
+  }
+
+  // optional bytes mediaKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_mediakey(), target);
+  }
+
+  // optional bytes fileEncSha256 = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_fileencsha256(), target);
+  }
+
+  // optional string directPath = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HistorySyncNotification.directPath");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_directpath(), target);
+  }
+
+  // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      6, this->_internal_synctype(), target);
+  }
+
+  // optional uint32 chunkOrder = 7;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_chunkorder(), target);
+  }
+
+  // optional string originalMessageId = 8;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_originalmessageid().data(), static_cast<int>(this->_internal_originalmessageid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.HistorySyncNotification.originalMessageId");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_originalmessageid(), target);
+  }
+
+  // optional uint32 progress = 9;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_progress(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.HistorySyncNotification)
+  return target;
+}
+
+size_t Message_HistorySyncNotification::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.HistorySyncNotification)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional bytes fileSha256 = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes mediaKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional bytes fileEncSha256 = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional string originalMessageId = 8;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_originalmessageid());
+    }
+
+    // optional uint64 fileLength = 2;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype());
+    }
+
+    // optional uint32 chunkOrder = 7;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder());
+    }
+
+  }
+  // optional uint32 progress = 9;
+  if (cached_has_bits & 0x00000100u) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HistorySyncNotification::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_HistorySyncNotification::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HistorySyncNotification::GetClassData() const { return &_class_data_; }
+
+
+void Message_HistorySyncNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_HistorySyncNotification*>(&to_msg);
+  auto& from = static_cast<const Message_HistorySyncNotification&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HistorySyncNotification)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_originalmessageid(from._internal_originalmessageid());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.synctype_ = from._impl_.synctype_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.chunkorder_ = from._impl_.chunkorder_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000100u) {
+    _this->_internal_set_progress(from._internal_progress());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_HistorySyncNotification::CopyFrom(const Message_HistorySyncNotification& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HistorySyncNotification)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_HistorySyncNotification::IsInitialized() const {
+  return true;
+}
+
+void Message_HistorySyncNotification::InternalSwap(Message_HistorySyncNotification* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.originalmessageid_, lhs_arena,
+      &other->_impl_.originalmessageid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.progress_)
+      + sizeof(Message_HistorySyncNotification::_impl_.progress_)
+      - PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.filelength_)>(
+          reinterpret_cast<char*>(&_impl_.filelength_),
+          reinterpret_cast<char*>(&other->_impl_.filelength_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_HistorySyncNotification::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[83]);
+}
+
+// ===================================================================
+
+class Message_ImageMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ImageMessage>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ImageMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_firstscansidecar(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_firstscanlength(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_experimentgroupid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static void set_has_scanssidecar(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_midqualityfilesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_midqualityfileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_viewonce(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static void set_has_thumbnaildirectpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_thumbnailsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_thumbnailencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_staticurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_ImageMessage::_Internal::contextinfo(const Message_ImageMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ImageMessage::Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ImageMessage)
+}
+Message_ImageMessage::Message_ImageMessage(const Message_ImageMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ImageMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_}
+    , decltype(_impl_.scanlengths_){from._impl_.scanlengths_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.firstscansidecar_){}
+    , decltype(_impl_.scanssidecar_){}
+    , decltype(_impl_.midqualityfilesha256_){}
+    , decltype(_impl_.midqualityfileencsha256_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.staticurl_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.mediakeytimestamp_){}
+    , decltype(_impl_.firstscanlength_){}
+    , decltype(_impl_.experimentgroupid_){}
+    , decltype(_impl_.viewonce_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.firstscansidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_firstscansidecar()) {
+    _this->_impl_.firstscansidecar_.Set(from._internal_firstscansidecar(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.scanssidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_scanssidecar()) {
+    _this->_impl_.scanssidecar_.Set(from._internal_scanssidecar(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.midqualityfilesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_midqualityfilesha256()) {
+    _this->_impl_.midqualityfilesha256_.Set(from._internal_midqualityfilesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.midqualityfileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_midqualityfileencsha256()) {
+    _this->_impl_.midqualityfileencsha256_.Set(from._internal_midqualityfileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnaildirectpath()) {
+    _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailsha256()) {
+    _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailencsha256()) {
+    _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.staticurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_staticurl()) {
+    _this->_impl_.staticurl_.Set(from._internal_staticurl(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.viewonce_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.viewonce_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ImageMessage)
+}
+
+inline void Message_ImageMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.interactiveannotations_){arena}
+    , decltype(_impl_.scanlengths_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.firstscansidecar_){}
+    , decltype(_impl_.scanssidecar_){}
+    , decltype(_impl_.midqualityfilesha256_){}
+    , decltype(_impl_.midqualityfileencsha256_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.staticurl_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.firstscanlength_){0u}
+    , decltype(_impl_.experimentgroupid_){0u}
+    , decltype(_impl_.viewonce_){false}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.firstscansidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.scanssidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.midqualityfilesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.midqualityfileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.staticurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ImageMessage::~Message_ImageMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ImageMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ImageMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.interactiveannotations_.~RepeatedPtrField();
+  _impl_.scanlengths_.~RepeatedField();
+  _impl_.url_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.caption_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.firstscansidecar_.Destroy();
+  _impl_.scanssidecar_.Destroy();
+  _impl_.midqualityfilesha256_.Destroy();
+  _impl_.midqualityfileencsha256_.Destroy();
+  _impl_.thumbnaildirectpath_.Destroy();
+  _impl_.thumbnailsha256_.Destroy();
+  _impl_.thumbnailencsha256_.Destroy();
+  _impl_.staticurl_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ImageMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ImageMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ImageMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.interactiveannotations_.Clear();
+  _impl_.scanlengths_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.firstscansidecar_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.scanssidecar_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.midqualityfilesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.midqualityfileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _impl_.thumbnailsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _impl_.staticurl_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00010000u) {
+    GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+    _impl_.contextinfo_->Clear();
+  }
+  if (cached_has_bits & 0x00fe0000u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.viewonce_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.viewonce_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ImageMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes firstScanSidecar = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          auto str = _internal_mutable_firstscansidecar();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 firstScanLength = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
+          _Internal::set_has_firstscanlength(&has_bits);
+          _impl_.firstscanlength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 experimentGroupId = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          _Internal::set_has_experimentgroupid(&has_bits);
+          _impl_.experimentgroupid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes scansSidecar = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_scanssidecar();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 scanLengths = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            _internal_add_scanlengths(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<176>(ptr));
+        } else if (static_cast<uint8_t>(tag) == 178) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_scanlengths(), ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes midQualityFileSha256 = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          auto str = _internal_mutable_midqualityfilesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes midQualityFileEncSha256 = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          auto str = _internal_mutable_midqualityfileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool viewOnce = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          _Internal::set_has_viewonce(&has_bits);
+          _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string thumbnailDirectPath = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          auto str = _internal_mutable_thumbnaildirectpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.thumbnailDirectPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailSha256 = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          auto str = _internal_mutable_thumbnailsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailEncSha256 = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          auto str = _internal_mutable_thumbnailencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string staticUrl = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          auto str = _internal_mutable_staticurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.staticUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ImageMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ImageMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string mimetype = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_mimetype(), target);
+  }
+
+  // optional string caption = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.caption");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_caption(), target);
+  }
+
+  // optional bytes fileSha256 = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_filesha256(), target);
+  }
+
+  // optional uint64 fileLength = 5;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target);
+  }
+
+  // optional uint32 height = 6;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target);
+  }
+
+  // optional uint32 width = 7;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target);
+  }
+
+  // optional bytes mediaKey = 8;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_mediakey(), target);
+  }
+
+  // optional bytes fileEncSha256 = 9;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        9, this->_internal_fileencsha256(), target);
+  }
+
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_interactiveannotations_size()); i < n; i++) {
+    const auto& repfield = this->_internal_interactiveannotations(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string directPath = 11;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.directPath");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_directpath(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 12;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00010000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes firstScanSidecar = 18;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->WriteBytesMaybeAliased(
+        18, this->_internal_firstscansidecar(), target);
+  }
+
+  // optional uint32 firstScanLength = 19;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_firstscanlength(), target);
+  }
+
+  // optional uint32 experimentGroupId = 20;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_experimentgroupid(), target);
+  }
+
+  // optional bytes scansSidecar = 21;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->WriteBytesMaybeAliased(
+        21, this->_internal_scanssidecar(), target);
+  }
+
+  // repeated uint32 scanLengths = 22;
+  for (int i = 0, n = this->_internal_scanlengths_size(); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(22, this->_internal_scanlengths(i), target);
+  }
+
+  // optional bytes midQualityFileSha256 = 23;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->WriteBytesMaybeAliased(
+        23, this->_internal_midqualityfilesha256(), target);
+  }
+
+  // optional bytes midQualityFileEncSha256 = 24;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->WriteBytesMaybeAliased(
+        24, this->_internal_midqualityfileencsha256(), target);
+  }
+
+  // optional bool viewOnce = 25;
+  if (cached_has_bits & 0x00800000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_viewonce(), target);
+  }
+
+  // optional string thumbnailDirectPath = 26;
+  if (cached_has_bits & 0x00001000u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_thumbnaildirectpath().data(), static_cast<int>(this->_internal_thumbnaildirectpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.thumbnailDirectPath");
+    target = stream->WriteStringMaybeAliased(
+        26, this->_internal_thumbnaildirectpath(), target);
+  }
+
+  // optional bytes thumbnailSha256 = 27;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->WriteBytesMaybeAliased(
+        27, this->_internal_thumbnailsha256(), target);
+  }
+
+  // optional bytes thumbnailEncSha256 = 28;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->WriteBytesMaybeAliased(
+        28, this->_internal_thumbnailencsha256(), target);
+  }
+
+  // optional string staticUrl = 29;
+  if (cached_has_bits & 0x00008000u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_staticurl().data(), static_cast<int>(this->_internal_staticurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ImageMessage.staticUrl");
+    target = stream->WriteStringMaybeAliased(
+        29, this->_internal_staticurl(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ImageMessage)
+  return target;
+}
+
+size_t Message_ImageMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ImageMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
+  total_size += 1UL * this->_internal_interactiveannotations_size();
+  for (const auto& msg : this->_impl_.interactiveannotations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated uint32 scanLengths = 22;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.scanlengths_);
+    total_size += 2 *
+                  ::_pbi::FromIntSize(this->_internal_scanlengths_size());
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string mimetype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional string caption = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional bytes fileSha256 = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes mediaKey = 8;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional bytes fileEncSha256 = 9;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 11;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional bytes firstScanSidecar = 18;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_firstscansidecar());
+    }
+
+    // optional bytes scansSidecar = 21;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_scanssidecar());
+    }
+
+    // optional bytes midQualityFileSha256 = 23;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_midqualityfilesha256());
+    }
+
+    // optional bytes midQualityFileEncSha256 = 24;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_midqualityfileencsha256());
+    }
+
+    // optional string thumbnailDirectPath = 26;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_thumbnaildirectpath());
+    }
+
+    // optional bytes thumbnailSha256 = 27;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailsha256());
+    }
+
+    // optional bytes thumbnailEncSha256 = 28;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailencsha256());
+    }
+
+    // optional string staticUrl = 29;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_staticurl());
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint64 fileLength = 5;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional uint32 height = 6;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional uint32 width = 7;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+    // optional int64 mediaKeyTimestamp = 12;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+    // optional uint32 firstScanLength = 19;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_firstscanlength());
+    }
+
+    // optional uint32 experimentGroupId = 20;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_experimentgroupid());
+    }
+
+    // optional bool viewOnce = 25;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ImageMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ImageMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ImageMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ImageMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ImageMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ImageMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ImageMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_);
+  _this->_impl_.scanlengths_.MergeFrom(from._impl_.scanlengths_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_firstscansidecar(from._internal_firstscansidecar());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_scanssidecar(from._internal_scanssidecar());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_midqualityfilesha256(from._internal_midqualityfilesha256());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_midqualityfileencsha256(from._internal_midqualityfileencsha256());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256());
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_internal_set_staticurl(from._internal_staticurl());
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.firstscanlength_ = from._impl_.firstscanlength_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.experimentgroupid_ = from._impl_.experimentgroupid_;
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_impl_.viewonce_ = from._impl_.viewonce_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ImageMessage::CopyFrom(const Message_ImageMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ImageMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ImageMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ImageMessage::InternalSwap(Message_ImageMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_);
+  _impl_.scanlengths_.InternalSwap(&other->_impl_.scanlengths_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.firstscansidecar_, lhs_arena,
+      &other->_impl_.firstscansidecar_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.scanssidecar_, lhs_arena,
+      &other->_impl_.scanssidecar_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.midqualityfilesha256_, lhs_arena,
+      &other->_impl_.midqualityfilesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.midqualityfileencsha256_, lhs_arena,
+      &other->_impl_.midqualityfileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnaildirectpath_, lhs_arena,
+      &other->_impl_.thumbnaildirectpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailsha256_, lhs_arena,
+      &other->_impl_.thumbnailsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailencsha256_, lhs_arena,
+      &other->_impl_.thumbnailencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.staticurl_, lhs_arena,
+      &other->_impl_.staticurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.viewonce_)
+      + sizeof(Message_ImageMessage::_impl_.viewonce_)
+      - PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ImageMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[84]);
+}
+
+// ===================================================================
+
+class Message_InitialSecurityNotificationSettingSync::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InitialSecurityNotificationSettingSync>()._impl_._has_bits_);
+  static void set_has_securitynotificationenabled(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InitialSecurityNotificationSettingSync)
+}
+Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InitialSecurityNotificationSettingSync* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.securitynotificationenabled_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.securitynotificationenabled_ = from._impl_.securitynotificationenabled_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InitialSecurityNotificationSettingSync)
+}
+
+inline void Message_InitialSecurityNotificationSettingSync::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.securitynotificationenabled_){false}
+  };
+}
+
+Message_InitialSecurityNotificationSettingSync::~Message_InitialSecurityNotificationSettingSync() {
+  // @@protoc_insertion_point(destructor:proto.Message.InitialSecurityNotificationSettingSync)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InitialSecurityNotificationSettingSync::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Message_InitialSecurityNotificationSettingSync::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InitialSecurityNotificationSettingSync::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InitialSecurityNotificationSettingSync)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.securitynotificationenabled_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InitialSecurityNotificationSettingSync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool securityNotificationEnabled = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_securitynotificationenabled(&has_bits);
+          _impl_.securitynotificationenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InitialSecurityNotificationSettingSync::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InitialSecurityNotificationSettingSync)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool securityNotificationEnabled = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_securitynotificationenabled(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InitialSecurityNotificationSettingSync)
+  return target;
+}
+
+size_t Message_InitialSecurityNotificationSettingSync::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InitialSecurityNotificationSettingSync)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool securityNotificationEnabled = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InitialSecurityNotificationSettingSync::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InitialSecurityNotificationSettingSync::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InitialSecurityNotificationSettingSync::GetClassData() const { return &_class_data_; }
+
+
+void Message_InitialSecurityNotificationSettingSync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InitialSecurityNotificationSettingSync*>(&to_msg);
+  auto& from = static_cast<const Message_InitialSecurityNotificationSettingSync&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InitialSecurityNotificationSettingSync)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_securitynotificationenabled()) {
+    _this->_internal_set_securitynotificationenabled(from._internal_securitynotificationenabled());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InitialSecurityNotificationSettingSync::CopyFrom(const Message_InitialSecurityNotificationSettingSync& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InitialSecurityNotificationSettingSync)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InitialSecurityNotificationSettingSync::IsInitialized() const {
+  return true;
+}
+
+void Message_InitialSecurityNotificationSettingSync::InternalSwap(Message_InitialSecurityNotificationSettingSync* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.securitynotificationenabled_, other->_impl_.securitynotificationenabled_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InitialSecurityNotificationSettingSync::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[85]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_Body::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_Body>()._impl_._has_bits_);
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Body)
+}
+Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_Body* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Body)
+}
+
+inline void Message_InteractiveMessage_Body::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_Body::~Message_InteractiveMessage_Body() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Body)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_Body::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+}
+
+void Message_InteractiveMessage_Body::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_Body::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Body)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.text_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string text = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Body.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_Body::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Body)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string text = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.Body.text");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_text(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.Body)
+  return target;
+}
+
+size_t Message_InteractiveMessage_Body::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Body)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string text = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_text());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Body::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_Body::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Body::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_Body*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_Body&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Body)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_text()) {
+    _this->_internal_set_text(from._internal_text());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_Body::CopyFrom(const Message_InteractiveMessage_Body& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Body)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_Body::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_Body::InternalSwap(Message_InteractiveMessage_Body* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Body::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[86]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_CollectionMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_CollectionMessage>()._impl_._has_bits_);
+  static void set_has_bizjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_messageversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.CollectionMessage)
+}
+Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_CollectionMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bizjid_){}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.messageversion_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.bizjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bizjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bizjid()) {
+    _this->_impl_.bizjid_.Set(from._internal_bizjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.messageversion_ = from._impl_.messageversion_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.CollectionMessage)
+}
+
+inline void Message_InteractiveMessage_CollectionMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bizjid_){}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.messageversion_){0}
+  };
+  _impl_.bizjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bizjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_CollectionMessage::~Message_InteractiveMessage_CollectionMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.CollectionMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_CollectionMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.bizjid_.Destroy();
+  _impl_.id_.Destroy();
+}
+
+void Message_InteractiveMessage_CollectionMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_CollectionMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.CollectionMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.bizjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.messageversion_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_CollectionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string bizJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_bizjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.bizJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 messageVersion = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_messageversion(&has_bits);
+          _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_CollectionMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.CollectionMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string bizJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_bizjid().data(), static_cast<int>(this->_internal_bizjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.CollectionMessage.bizJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_bizjid(), target);
+  }
+
+  // optional string id = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.CollectionMessage.id");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_id(), target);
+  }
+
+  // optional int32 messageVersion = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.CollectionMessage)
+  return target;
+}
+
+size_t Message_InteractiveMessage_CollectionMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.CollectionMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string bizJid = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_bizjid());
+    }
+
+    // optional string id = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional int32 messageVersion = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_CollectionMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_CollectionMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_CollectionMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_CollectionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_CollectionMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_CollectionMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.CollectionMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_bizjid(from._internal_bizjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.messageversion_ = from._impl_.messageversion_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_CollectionMessage::CopyFrom(const Message_InteractiveMessage_CollectionMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.CollectionMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_CollectionMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_CollectionMessage::InternalSwap(Message_InteractiveMessage_CollectionMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bizjid_, lhs_arena,
+      &other->_impl_.bizjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  swap(_impl_.messageversion_, other->_impl_.messageversion_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_CollectionMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[87]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_Footer::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_Footer>()._impl_._has_bits_);
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Footer)
+}
+Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_Footer* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Footer)
+}
+
+inline void Message_InteractiveMessage_Footer::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_Footer::~Message_InteractiveMessage_Footer() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Footer)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_Footer::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+}
+
+void Message_InteractiveMessage_Footer::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_Footer::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Footer)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.text_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_Footer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string text = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Footer.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_Footer::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Footer)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string text = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.Footer.text");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_text(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.Footer)
+  return target;
+}
+
+size_t Message_InteractiveMessage_Footer::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Footer)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string text = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_text());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Footer::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_Footer::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Footer::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_Footer::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_Footer*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_Footer&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Footer)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_text()) {
+    _this->_internal_set_text(from._internal_text());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_Footer::CopyFrom(const Message_InteractiveMessage_Footer& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Footer)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_Footer::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_Footer::InternalSwap(Message_InteractiveMessage_Footer* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Footer::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[88]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_Header::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_Header>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_subtitle(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_hasmediaattachment(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::Message_DocumentMessage& documentmessage(const Message_InteractiveMessage_Header* msg);
+  static const ::proto::Message_ImageMessage& imagemessage(const Message_InteractiveMessage_Header* msg);
+  static const ::proto::Message_VideoMessage& videomessage(const Message_InteractiveMessage_Header* msg);
+};
+
+const ::proto::Message_DocumentMessage&
+Message_InteractiveMessage_Header::_Internal::documentmessage(const Message_InteractiveMessage_Header* msg) {
+  return *msg->_impl_.media_.documentmessage_;
+}
+const ::proto::Message_ImageMessage&
+Message_InteractiveMessage_Header::_Internal::imagemessage(const Message_InteractiveMessage_Header* msg) {
+  return *msg->_impl_.media_.imagemessage_;
+}
+const ::proto::Message_VideoMessage&
+Message_InteractiveMessage_Header::_Internal::videomessage(const Message_InteractiveMessage_Header* msg) {
+  return *msg->_impl_.media_.videomessage_;
+}
+void Message_InteractiveMessage_Header::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_media();
+  if (documentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
+    if (message_arena != submessage_arena) {
+      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentmessage, submessage_arena);
+    }
+    set_has_documentmessage();
+    _impl_.media_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage)
+}
+void Message_InteractiveMessage_Header::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_media();
+  if (imagemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
+    if (message_arena != submessage_arena) {
+      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, imagemessage, submessage_arena);
+    }
+    set_has_imagemessage();
+    _impl_.media_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage)
+}
+void Message_InteractiveMessage_Header::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_media();
+  if (videomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
+    if (message_arena != submessage_arena) {
+      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, videomessage, submessage_arena);
+    }
+    set_has_videomessage();
+    _impl_.media_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage)
+}
+Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Header)
+}
+Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_Header* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.subtitle_){}
+    , decltype(_impl_.hasmediaattachment_){}
+    , decltype(_impl_.media_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.subtitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.subtitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_subtitle()) {
+    _this->_impl_.subtitle_.Set(from._internal_subtitle(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_;
+  clear_has_media();
+  switch (from.media_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kJpegThumbnail: {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case MEDIA_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Header)
+}
+
+inline void Message_InteractiveMessage_Header::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.subtitle_){}
+    , decltype(_impl_.hasmediaattachment_){false}
+    , decltype(_impl_.media_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.subtitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.subtitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  clear_has_media();
+}
+
+Message_InteractiveMessage_Header::~Message_InteractiveMessage_Header() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Header)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_Header::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.title_.Destroy();
+  _impl_.subtitle_.Destroy();
+  if (has_media()) {
+    clear_media();
+  }
+}
+
+void Message_InteractiveMessage_Header::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_Header::clear_media() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage.Header)
+  switch (media_case()) {
+    case kDocumentMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.media_.documentmessage_;
+      }
+      break;
+    }
+    case kImageMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.media_.imagemessage_;
+      }
+      break;
+    }
+    case kJpegThumbnail: {
+      _impl_.media_.jpegthumbnail_.Destroy();
+      break;
+    }
+    case kVideoMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.media_.videomessage_;
+      }
+      break;
+    }
+    case MEDIA_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = MEDIA_NOT_SET;
+}
+
+
+void Message_InteractiveMessage_Header::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Header)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.subtitle_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.hasmediaattachment_ = false;
+  clear_media();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_Header::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string subtitle = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_subtitle();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.subtitle");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.DocumentMessage documentMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.ImageMessage imageMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool hasMediaAttachment = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_hasmediaattachment(&has_bits);
+          _impl_.hasmediaattachment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes jpegThumbnail = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.VideoMessage videoMessage = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_Header::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Header)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.Header.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // optional string subtitle = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_subtitle().data(), static_cast<int>(this->_internal_subtitle().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.Header.subtitle");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_subtitle(), target);
+  }
+
+  switch (media_case()) {
+    case kDocumentMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::documentmessage(this),
+          _Internal::documentmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kImageMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, _Internal::imagemessage(this),
+          _Internal::imagemessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  // optional bool hasMediaAttachment = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_hasmediaattachment(), target);
+  }
+
+  switch (media_case()) {
+    case kJpegThumbnail: {
+      target = stream->WriteBytesMaybeAliased(
+          6, this->_internal_jpegthumbnail(), target);
+      break;
+    }
+    case kVideoMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(7, _Internal::videomessage(this),
+          _Internal::videomessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.Header)
+  return target;
+}
+
+size_t Message_InteractiveMessage_Header::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Header)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string title = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string subtitle = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_subtitle());
+    }
+
+    // optional bool hasMediaAttachment = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  switch (media_case()) {
+    // .proto.Message.DocumentMessage documentMessage = 3;
+    case kDocumentMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.media_.documentmessage_);
+      break;
+    }
+    // .proto.Message.ImageMessage imageMessage = 4;
+    case kImageMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.media_.imagemessage_);
+      break;
+    }
+    // bytes jpegThumbnail = 6;
+    case kJpegThumbnail: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+      break;
+    }
+    // .proto.Message.VideoMessage videoMessage = 7;
+    case kVideoMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.media_.videomessage_);
+      break;
+    }
+    case MEDIA_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Header::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_Header::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Header::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_Header::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_Header*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_Header&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Header)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_subtitle(from._internal_subtitle());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  switch (from.media_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kJpegThumbnail: {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case MEDIA_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_Header::CopyFrom(const Message_InteractiveMessage_Header& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Header)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_Header::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_Header::InternalSwap(Message_InteractiveMessage_Header* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.subtitle_, lhs_arena,
+      &other->_impl_.subtitle_, rhs_arena
+  );
+  swap(_impl_.hasmediaattachment_, other->_impl_.hasmediaattachment_);
+  swap(_impl_.media_, other->_impl_.media_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Header::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[89]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_buttonparamsjson(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+}
+Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.buttonparamsjson_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.buttonparamsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_buttonparamsjson()) {
+    _this->_impl_.buttonparamsjson_.Set(from._internal_buttonparamsjson(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+}
+
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.buttonparamsjson_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.buttonparamsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.buttonparamsjson_.Destroy();
+}
+
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.buttonparamsjson_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string buttonParamsJson = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_buttonparamsjson();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional string buttonParamsJson = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_buttonparamsjson().data(), static_cast<int>(this->_internal_buttonparamsjson().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_buttonparamsjson(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  return target;
+}
+
+size_t Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string buttonParamsJson = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_buttonparamsjson());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_buttonparamsjson(from._internal_buttonparamsjson());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.buttonparamsjson_, lhs_arena,
+      &other->_impl_.buttonparamsjson_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[90]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_NativeFlowMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_NativeFlowMessage>()._impl_._has_bits_);
+  static void set_has_messageparamsjson(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_messageversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage)
+}
+Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_NativeFlowMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){from._impl_.buttons_}
+    , decltype(_impl_.messageparamsjson_){}
+    , decltype(_impl_.messageversion_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.messageparamsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_messageparamsjson()) {
+    _this->_impl_.messageparamsjson_.Set(from._internal_messageparamsjson(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.messageversion_ = from._impl_.messageversion_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage)
+}
+
+inline void Message_InteractiveMessage_NativeFlowMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){arena}
+    , decltype(_impl_.messageparamsjson_){}
+    , decltype(_impl_.messageversion_){0}
+  };
+  _impl_.messageparamsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_NativeFlowMessage::~Message_InteractiveMessage_NativeFlowMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_NativeFlowMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.buttons_.~RepeatedPtrField();
+  _impl_.messageparamsjson_.Destroy();
+}
+
+void Message_InteractiveMessage_NativeFlowMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_NativeFlowMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.buttons_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.messageparamsjson_.ClearNonDefaultToEmpty();
+  }
+  _impl_.messageversion_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_NativeFlowMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_buttons(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string messageParamsJson = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_messageparamsjson();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 messageVersion = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_messageversion(&has_bits);
+          _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_NativeFlowMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_buttons_size()); i < n; i++) {
+    const auto& repfield = this->_internal_buttons(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string messageParamsJson = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_messageparamsjson().data(), static_cast<int>(this->_internal_messageparamsjson().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_messageparamsjson(), target);
+  }
+
+  // optional int32 messageVersion = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.NativeFlowMessage)
+  return target;
+}
+
+size_t Message_InteractiveMessage_NativeFlowMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
+  total_size += 1UL * this->_internal_buttons_size();
+  for (const auto& msg : this->_impl_.buttons_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string messageParamsJson = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_messageparamsjson());
+    }
+
+    // optional int32 messageVersion = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_NativeFlowMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_NativeFlowMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_NativeFlowMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_NativeFlowMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_messageparamsjson(from._internal_messageparamsjson());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.messageversion_ = from._impl_.messageversion_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_NativeFlowMessage::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_NativeFlowMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_NativeFlowMessage::InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.buttons_.InternalSwap(&other->_impl_.buttons_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.messageparamsjson_, lhs_arena,
+      &other->_impl_.messageparamsjson_, rhs_arena
+  );
+  swap(_impl_.messageversion_, other->_impl_.messageversion_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[91]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage_ShopMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage_ShopMessage>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_surface(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_messageversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.ShopMessage)
+}
+Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage_ShopMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.surface_){}
+    , decltype(_impl_.messageversion_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.surface_, &from._impl_.surface_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.messageversion_) -
+    reinterpret_cast<char*>(&_impl_.surface_)) + sizeof(_impl_.messageversion_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.ShopMessage)
+}
+
+inline void Message_InteractiveMessage_ShopMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.surface_){0}
+    , decltype(_impl_.messageversion_){0}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveMessage_ShopMessage::~Message_InteractiveMessage_ShopMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.ShopMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage_ShopMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+}
+
+void Message_InteractiveMessage_ShopMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage_ShopMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.ShopMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.id_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.surface_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.messageversion_) -
+        reinterpret_cast<char*>(&_impl_.surface_)) + sizeof(_impl_.messageversion_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage_ShopMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.ShopMessage.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(val))) {
+            _internal_set_surface(static_cast<::proto::Message_InteractiveMessage_ShopMessage_Surface>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 messageVersion = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_messageversion(&has_bits);
+          _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage_ShopMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.ShopMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveMessage.ShopMessage.id");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_surface(), target);
+  }
+
+  // optional int32 messageVersion = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage.ShopMessage)
+  return target;
+}
+
+size_t Message_InteractiveMessage_ShopMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.ShopMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string id = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_surface());
+    }
+
+    // optional int32 messageVersion = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_ShopMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage_ShopMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_ShopMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage_ShopMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage_ShopMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage_ShopMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.ShopMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.surface_ = from._impl_.surface_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.messageversion_ = from._impl_.messageversion_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage_ShopMessage::CopyFrom(const Message_InteractiveMessage_ShopMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.ShopMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage_ShopMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage_ShopMessage::InternalSwap(Message_InteractiveMessage_ShopMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.messageversion_)
+      + sizeof(Message_InteractiveMessage_ShopMessage::_impl_.messageversion_)
+      - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.surface_)>(
+          reinterpret_cast<char*>(&_impl_.surface_),
+          reinterpret_cast<char*>(&other->_impl_.surface_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_ShopMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[92]);
+}
+
+// ===================================================================
+
+class Message_InteractiveMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveMessage>()._impl_._has_bits_);
+  static const ::proto::Message_InteractiveMessage_Header& header(const Message_InteractiveMessage* msg);
+  static void set_has_header(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_InteractiveMessage_Body& body(const Message_InteractiveMessage* msg);
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_InteractiveMessage_Footer& footer(const Message_InteractiveMessage* msg);
+  static void set_has_footer(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_InteractiveMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage(const Message_InteractiveMessage* msg);
+  static const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage(const Message_InteractiveMessage* msg);
+  static const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage(const Message_InteractiveMessage* msg);
+};
+
+const ::proto::Message_InteractiveMessage_Header&
+Message_InteractiveMessage::_Internal::header(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.header_;
+}
+const ::proto::Message_InteractiveMessage_Body&
+Message_InteractiveMessage::_Internal::body(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.body_;
+}
+const ::proto::Message_InteractiveMessage_Footer&
+Message_InteractiveMessage::_Internal::footer(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.footer_;
+}
+const ::proto::ContextInfo&
+Message_InteractiveMessage::_Internal::contextinfo(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+const ::proto::Message_InteractiveMessage_ShopMessage&
+Message_InteractiveMessage::_Internal::shopstorefrontmessage(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.interactiveMessage_.shopstorefrontmessage_;
+}
+const ::proto::Message_InteractiveMessage_CollectionMessage&
+Message_InteractiveMessage::_Internal::collectionmessage(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.interactiveMessage_.collectionmessage_;
+}
+const ::proto::Message_InteractiveMessage_NativeFlowMessage&
+Message_InteractiveMessage::_Internal::nativeflowmessage(const Message_InteractiveMessage* msg) {
+  return *msg->_impl_.interactiveMessage_.nativeflowmessage_;
+}
+void Message_InteractiveMessage::set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_interactiveMessage();
+  if (shopstorefrontmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shopstorefrontmessage);
+    if (message_arena != submessage_arena) {
+      shopstorefrontmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shopstorefrontmessage, submessage_arena);
+    }
+    set_has_shopstorefrontmessage();
+    _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage)
+}
+void Message_InteractiveMessage::set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_interactiveMessage();
+  if (collectionmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(collectionmessage);
+    if (message_arena != submessage_arena) {
+      collectionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, collectionmessage, submessage_arena);
+    }
+    set_has_collectionmessage();
+    _impl_.interactiveMessage_.collectionmessage_ = collectionmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.collectionMessage)
+}
+void Message_InteractiveMessage::set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_interactiveMessage();
+  if (nativeflowmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowmessage);
+    if (message_arena != submessage_arena) {
+      nativeflowmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, nativeflowmessage, submessage_arena);
+    }
+    set_has_nativeflowmessage();
+    _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage)
+}
+Message_InteractiveMessage::Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage)
+}
+Message_InteractiveMessage::Message_InteractiveMessage(const Message_InteractiveMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.header_){nullptr}
+    , decltype(_impl_.body_){nullptr}
+    , decltype(_impl_.footer_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.interactiveMessage_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_header()) {
+    _this->_impl_.header_ = new ::proto::Message_InteractiveMessage_Header(*from._impl_.header_);
+  }
+  if (from._internal_has_body()) {
+    _this->_impl_.body_ = new ::proto::Message_InteractiveMessage_Body(*from._impl_.body_);
+  }
+  if (from._internal_has_footer()) {
+    _this->_impl_.footer_ = new ::proto::Message_InteractiveMessage_Footer(*from._impl_.footer_);
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  clear_has_interactiveMessage();
+  switch (from.interactiveMessage_case()) {
+    case kShopStorefrontMessage: {
+      _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom(
+          from._internal_shopstorefrontmessage());
+      break;
+    }
+    case kCollectionMessage: {
+      _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom(
+          from._internal_collectionmessage());
+      break;
+    }
+    case kNativeFlowMessage: {
+      _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom(
+          from._internal_nativeflowmessage());
+      break;
+    }
+    case INTERACTIVEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage)
+}
+
+inline void Message_InteractiveMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.header_){nullptr}
+    , decltype(_impl_.body_){nullptr}
+    , decltype(_impl_.footer_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.interactiveMessage_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_interactiveMessage();
+}
+
+Message_InteractiveMessage::~Message_InteractiveMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.header_;
+  if (this != internal_default_instance()) delete _impl_.body_;
+  if (this != internal_default_instance()) delete _impl_.footer_;
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+  if (has_interactiveMessage()) {
+    clear_interactiveMessage();
+  }
+}
+
+void Message_InteractiveMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveMessage::clear_interactiveMessage() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage)
+  switch (interactiveMessage_case()) {
+    case kShopStorefrontMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.interactiveMessage_.shopstorefrontmessage_;
+      }
+      break;
+    }
+    case kCollectionMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.interactiveMessage_.collectionmessage_;
+      }
+      break;
+    }
+    case kNativeFlowMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.interactiveMessage_.nativeflowmessage_;
+      }
+      break;
+    }
+    case INTERACTIVEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET;
+}
+
+
+void Message_InteractiveMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.header_ != nullptr);
+      _impl_.header_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.body_ != nullptr);
+      _impl_.body_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.footer_ != nullptr);
+      _impl_.footer_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  clear_interactiveMessage();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.InteractiveMessage.Header header = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_header(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InteractiveMessage.Body body = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_body(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InteractiveMessage.Footer footer = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_shopstorefrontmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_collectionmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_nativeflowmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.InteractiveMessage.Header header = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::header(this),
+        _Internal::header(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.InteractiveMessage.Body body = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::body(this),
+        _Internal::body(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.InteractiveMessage.Footer footer = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::footer(this),
+        _Internal::footer(this).GetCachedSize(), target, stream);
+  }
+
+  switch (interactiveMessage_case()) {
+    case kShopStorefrontMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, _Internal::shopstorefrontmessage(this),
+          _Internal::shopstorefrontmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kCollectionMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, _Internal::collectionmessage(this),
+          _Internal::collectionmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kNativeFlowMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(6, _Internal::nativeflowmessage(this),
+          _Internal::nativeflowmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  // optional .proto.ContextInfo contextInfo = 15;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveMessage)
+  return target;
+}
+
+size_t Message_InteractiveMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional .proto.Message.InteractiveMessage.Header header = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.header_);
+    }
+
+    // optional .proto.Message.InteractiveMessage.Body body = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.body_);
+    }
+
+    // optional .proto.Message.InteractiveMessage.Footer footer = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.footer_);
+    }
+
+    // optional .proto.ContextInfo contextInfo = 15;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  switch (interactiveMessage_case()) {
+    // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
+    case kShopStorefrontMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactiveMessage_.shopstorefrontmessage_);
+      break;
+    }
+    // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
+    case kCollectionMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactiveMessage_.collectionmessage_);
+      break;
+    }
+    // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
+    case kNativeFlowMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactiveMessage_.nativeflowmessage_);
+      break;
+    }
+    case INTERACTIVEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_header()->::proto::Message_InteractiveMessage_Header::MergeFrom(
+          from._internal_header());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_body()->::proto::Message_InteractiveMessage_Body::MergeFrom(
+          from._internal_body());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_footer()->::proto::Message_InteractiveMessage_Footer::MergeFrom(
+          from._internal_footer());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  switch (from.interactiveMessage_case()) {
+    case kShopStorefrontMessage: {
+      _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom(
+          from._internal_shopstorefrontmessage());
+      break;
+    }
+    case kCollectionMessage: {
+      _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom(
+          from._internal_collectionmessage());
+      break;
+    }
+    case kNativeFlowMessage: {
+      _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom(
+          from._internal_nativeflowmessage());
+      break;
+    }
+    case INTERACTIVEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveMessage::CopyFrom(const Message_InteractiveMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveMessage::InternalSwap(Message_InteractiveMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.contextinfo_)
+      + sizeof(Message_InteractiveMessage::_impl_.contextinfo_)
+      - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.header_)>(
+          reinterpret_cast<char*>(&_impl_.header_),
+          reinterpret_cast<char*>(&other->_impl_.header_));
+  swap(_impl_.interactiveMessage_, other->_impl_.interactiveMessage_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[93]);
+}
+
+// ===================================================================
+
+class Message_InteractiveResponseMessage_Body::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveResponseMessage_Body>()._impl_._has_bits_);
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.Body)
+}
+Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveResponseMessage_Body* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.Body)
+}
+
+inline void Message_InteractiveResponseMessage_Body::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveResponseMessage_Body::~Message_InteractiveResponseMessage_Body() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.Body)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveResponseMessage_Body::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+}
+
+void Message_InteractiveResponseMessage_Body::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveResponseMessage_Body::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.Body)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.text_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveResponseMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string text = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.Body.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveResponseMessage_Body::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.Body)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string text = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveResponseMessage.Body.text");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_text(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveResponseMessage.Body)
+  return target;
+}
+
+size_t Message_InteractiveResponseMessage_Body::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.Body)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string text = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_text());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_Body::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveResponseMessage_Body::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_Body::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveResponseMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveResponseMessage_Body*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveResponseMessage_Body&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.Body)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_text()) {
+    _this->_internal_set_text(from._internal_text());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveResponseMessage_Body::CopyFrom(const Message_InteractiveResponseMessage_Body& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.Body)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveResponseMessage_Body::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveResponseMessage_Body::InternalSwap(Message_InteractiveResponseMessage_Body* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_Body::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[94]);
+}
+
+// ===================================================================
+
+class Message_InteractiveResponseMessage_NativeFlowResponseMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveResponseMessage_NativeFlowResponseMessage>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_paramsjson(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+}
+Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveResponseMessage_NativeFlowResponseMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.paramsjson_){}
+    , decltype(_impl_.version_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.paramsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_paramsjson()) {
+    _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.version_ = from._impl_.version_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+}
+
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.paramsjson_){}
+    , decltype(_impl_.version_){0}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.paramsjson_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InteractiveResponseMessage_NativeFlowResponseMessage::~Message_InteractiveResponseMessage_NativeFlowResponseMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.paramsjson_.Destroy();
+}
+
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.paramsjson_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.version_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string paramsJson = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_paramsjson();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 version = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_version(&has_bits);
+          _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional string paramsJson = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_paramsjson().data(), static_cast<int>(this->_internal_paramsjson().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_paramsjson(), target);
+  }
+
+  // optional int32 version = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  return target;
+}
+
+size_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string paramsJson = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_paramsjson());
+    }
+
+    // optional int32 version = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_NativeFlowResponseMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveResponseMessage_NativeFlowResponseMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveResponseMessage_NativeFlowResponseMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_paramsjson(from._internal_paramsjson());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.version_ = from._impl_.version_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.paramsjson_, lhs_arena,
+      &other->_impl_.paramsjson_, rhs_arena
+  );
+  swap(_impl_.version_, other->_impl_.version_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[95]);
+}
+
+// ===================================================================
+
+class Message_InteractiveResponseMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InteractiveResponseMessage>()._impl_._has_bits_);
+  static const ::proto::Message_InteractiveResponseMessage_Body& body(const Message_InteractiveResponseMessage* msg);
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_InteractiveResponseMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg);
+};
+
+const ::proto::Message_InteractiveResponseMessage_Body&
+Message_InteractiveResponseMessage::_Internal::body(const Message_InteractiveResponseMessage* msg) {
+  return *msg->_impl_.body_;
+}
+const ::proto::ContextInfo&
+Message_InteractiveResponseMessage::_Internal::contextinfo(const Message_InteractiveResponseMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage&
+Message_InteractiveResponseMessage::_Internal::nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg) {
+  return *msg->_impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+}
+void Message_InteractiveResponseMessage::set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_interactiveResponseMessage();
+  if (nativeflowresponsemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowresponsemessage);
+    if (message_arena != submessage_arena) {
+      nativeflowresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, nativeflowresponsemessage, submessage_arena);
+    }
+    set_has_nativeflowresponsemessage();
+    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+}
+Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage)
+}
+Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InteractiveResponseMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.body_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.interactiveResponseMessage_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_body()) {
+    _this->_impl_.body_ = new ::proto::Message_InteractiveResponseMessage_Body(*from._impl_.body_);
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  clear_has_interactiveResponseMessage();
+  switch (from.interactiveResponseMessage_case()) {
+    case kNativeFlowResponseMessage: {
+      _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom(
+          from._internal_nativeflowresponsemessage());
+      break;
+    }
+    case INTERACTIVERESPONSEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage)
+}
+
+inline void Message_InteractiveResponseMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.body_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.interactiveResponseMessage_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_interactiveResponseMessage();
+}
+
+Message_InteractiveResponseMessage::~Message_InteractiveResponseMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InteractiveResponseMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.body_;
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+  if (has_interactiveResponseMessage()) {
+    clear_interactiveResponseMessage();
+  }
+}
+
+void Message_InteractiveResponseMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InteractiveResponseMessage::clear_interactiveResponseMessage() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveResponseMessage)
+  switch (interactiveResponseMessage_case()) {
+    case kNativeFlowResponseMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+      }
+      break;
+    }
+    case INTERACTIVERESPONSEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET;
+}
+
+
+void Message_InteractiveResponseMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.body_ != nullptr);
+      _impl_.body_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  clear_interactiveResponseMessage();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InteractiveResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.InteractiveResponseMessage.Body body = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_body(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_nativeflowresponsemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InteractiveResponseMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.InteractiveResponseMessage.Body body = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::body(this),
+        _Internal::body(this).GetCachedSize(), target, stream);
+  }
+
+  // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+  if (_internal_has_nativeflowresponsemessage()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::nativeflowresponsemessage(this),
+        _Internal::nativeflowresponsemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 15;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InteractiveResponseMessage)
+  return target;
+}
+
+size_t Message_InteractiveResponseMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.Message.InteractiveResponseMessage.Body body = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.body_);
+    }
+
+    // optional .proto.ContextInfo contextInfo = 15;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  switch (interactiveResponseMessage_case()) {
+    // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+    case kNativeFlowResponseMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_);
+      break;
+    }
+    case INTERACTIVERESPONSEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InteractiveResponseMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InteractiveResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InteractiveResponseMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InteractiveResponseMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_body()->::proto::Message_InteractiveResponseMessage_Body::MergeFrom(
+          from._internal_body());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  switch (from.interactiveResponseMessage_case()) {
+    case kNativeFlowResponseMessage: {
+      _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom(
+          from._internal_nativeflowresponsemessage());
+      break;
+    }
+    case INTERACTIVERESPONSEMESSAGE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InteractiveResponseMessage::CopyFrom(const Message_InteractiveResponseMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InteractiveResponseMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InteractiveResponseMessage::InternalSwap(Message_InteractiveResponseMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.contextinfo_)
+      + sizeof(Message_InteractiveResponseMessage::_impl_.contextinfo_)
+      - PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.body_)>(
+          reinterpret_cast<char*>(&_impl_.body_),
+          reinterpret_cast<char*>(&other->_impl_.body_));
+  swap(_impl_.interactiveResponseMessage_, other->_impl_.interactiveResponseMessage_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[96]);
+}
+
+// ===================================================================
+
+class Message_InvoiceMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_InvoiceMessage>()._impl_._has_bits_);
+  static void set_has_note(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_attachmenttype(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_attachmentmimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_attachmentmediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_attachmentmediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_attachmentfilesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_attachmentfileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_attachmentdirectpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_attachmentjpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+Message_InvoiceMessage::Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.InvoiceMessage)
+}
+Message_InvoiceMessage::Message_InvoiceMessage(const Message_InvoiceMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_InvoiceMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.note_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.attachmentmimetype_){}
+    , decltype(_impl_.attachmentmediakey_){}
+    , decltype(_impl_.attachmentfilesha256_){}
+    , decltype(_impl_.attachmentfileencsha256_){}
+    , decltype(_impl_.attachmentdirectpath_){}
+    , decltype(_impl_.attachmentjpegthumbnail_){}
+    , decltype(_impl_.attachmentmediakeytimestamp_){}
+    , decltype(_impl_.attachmenttype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.note_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.note_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_note()) {
+    _this->_impl_.note_.Set(from._internal_note(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentmimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentmimetype()) {
+    _this->_impl_.attachmentmimetype_.Set(from._internal_attachmentmimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentmediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentmediakey()) {
+    _this->_impl_.attachmentmediakey_.Set(from._internal_attachmentmediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentfilesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentfilesha256()) {
+    _this->_impl_.attachmentfilesha256_.Set(from._internal_attachmentfilesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentfileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentfileencsha256()) {
+    _this->_impl_.attachmentfileencsha256_.Set(from._internal_attachmentfileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentdirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentdirectpath()) {
+    _this->_impl_.attachmentdirectpath_.Set(from._internal_attachmentdirectpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.attachmentjpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_attachmentjpegthumbnail()) {
+    _this->_impl_.attachmentjpegthumbnail_.Set(from._internal_attachmentjpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.attachmentmediakeytimestamp_, &from._impl_.attachmentmediakeytimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.attachmenttype_) -
+    reinterpret_cast<char*>(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.InvoiceMessage)
+}
+
+inline void Message_InvoiceMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.note_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.attachmentmimetype_){}
+    , decltype(_impl_.attachmentmediakey_){}
+    , decltype(_impl_.attachmentfilesha256_){}
+    , decltype(_impl_.attachmentfileencsha256_){}
+    , decltype(_impl_.attachmentdirectpath_){}
+    , decltype(_impl_.attachmentjpegthumbnail_){}
+    , decltype(_impl_.attachmentmediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.attachmenttype_){0}
+  };
+  _impl_.note_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.note_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentmimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentmediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentfilesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentfileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentdirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.attachmentjpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_InvoiceMessage::~Message_InvoiceMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.InvoiceMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_InvoiceMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.note_.Destroy();
+  _impl_.token_.Destroy();
+  _impl_.attachmentmimetype_.Destroy();
+  _impl_.attachmentmediakey_.Destroy();
+  _impl_.attachmentfilesha256_.Destroy();
+  _impl_.attachmentfileencsha256_.Destroy();
+  _impl_.attachmentdirectpath_.Destroy();
+  _impl_.attachmentjpegthumbnail_.Destroy();
+}
+
+void Message_InvoiceMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_InvoiceMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.InvoiceMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.note_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.attachmentmimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.attachmentmediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.attachmentfilesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.attachmentfileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.attachmentdirectpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.attachmentjpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.attachmentmediakeytimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.attachmenttype_) -
+        reinterpret_cast<char*>(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_InvoiceMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string note = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_note();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.note");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string token = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.token");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_InvoiceMessage_AttachmentType_IsValid(val))) {
+            _internal_set_attachmenttype(static_cast<::proto::Message_InvoiceMessage_AttachmentType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string attachmentMimetype = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_attachmentmimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentMimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes attachmentMediaKey = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_attachmentmediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 attachmentMediaKeyTimestamp = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_attachmentmediakeytimestamp(&has_bits);
+          _impl_.attachmentmediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes attachmentFileSha256 = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_attachmentfilesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes attachmentFileEncSha256 = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_attachmentfileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string attachmentDirectPath = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_attachmentdirectpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentDirectPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes attachmentJpegThumbnail = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          auto str = _internal_mutable_attachmentjpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_InvoiceMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InvoiceMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string note = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_note().data(), static_cast<int>(this->_internal_note().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InvoiceMessage.note");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_note(), target);
+  }
+
+  // optional string token = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_token().data(), static_cast<int>(this->_internal_token().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InvoiceMessage.token");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_token(), target);
+  }
+
+  // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_attachmenttype(), target);
+  }
+
+  // optional string attachmentMimetype = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_attachmentmimetype().data(), static_cast<int>(this->_internal_attachmentmimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InvoiceMessage.attachmentMimetype");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_attachmentmimetype(), target);
+  }
+
+  // optional bytes attachmentMediaKey = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_attachmentmediakey(), target);
+  }
+
+  // optional int64 attachmentMediaKeyTimestamp = 6;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_attachmentmediakeytimestamp(), target);
+  }
+
+  // optional bytes attachmentFileSha256 = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        7, this->_internal_attachmentfilesha256(), target);
+  }
+
+  // optional bytes attachmentFileEncSha256 = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_attachmentfileencsha256(), target);
+  }
+
+  // optional string attachmentDirectPath = 9;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_attachmentdirectpath().data(), static_cast<int>(this->_internal_attachmentdirectpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.InvoiceMessage.attachmentDirectPath");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_attachmentdirectpath(), target);
+  }
+
+  // optional bytes attachmentJpegThumbnail = 10;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        10, this->_internal_attachmentjpegthumbnail(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.InvoiceMessage)
+  return target;
+}
+
+size_t Message_InvoiceMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.InvoiceMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string note = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_note());
+    }
+
+    // optional string token = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_token());
+    }
+
+    // optional string attachmentMimetype = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_attachmentmimetype());
+    }
+
+    // optional bytes attachmentMediaKey = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_attachmentmediakey());
+    }
+
+    // optional bytes attachmentFileSha256 = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_attachmentfilesha256());
+    }
+
+    // optional bytes attachmentFileEncSha256 = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_attachmentfileencsha256());
+    }
+
+    // optional string attachmentDirectPath = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_attachmentdirectpath());
+    }
+
+    // optional bytes attachmentJpegThumbnail = 10;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_attachmentjpegthumbnail());
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional int64 attachmentMediaKeyTimestamp = 6;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_attachmentmediakeytimestamp());
+    }
+
+    // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_attachmenttype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InvoiceMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_InvoiceMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InvoiceMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_InvoiceMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_InvoiceMessage*>(&to_msg);
+  auto& from = static_cast<const Message_InvoiceMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InvoiceMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_note(from._internal_note());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_attachmentmimetype(from._internal_attachmentmimetype());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_attachmentmediakey(from._internal_attachmentmediakey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_attachmentfilesha256(from._internal_attachmentfilesha256());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_attachmentfileencsha256(from._internal_attachmentfileencsha256());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_attachmentdirectpath(from._internal_attachmentdirectpath());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_attachmentjpegthumbnail(from._internal_attachmentjpegthumbnail());
+    }
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.attachmentmediakeytimestamp_ = from._impl_.attachmentmediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.attachmenttype_ = from._impl_.attachmenttype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_InvoiceMessage::CopyFrom(const Message_InvoiceMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InvoiceMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_InvoiceMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_InvoiceMessage::InternalSwap(Message_InvoiceMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.note_, lhs_arena,
+      &other->_impl_.note_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentmimetype_, lhs_arena,
+      &other->_impl_.attachmentmimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentmediakey_, lhs_arena,
+      &other->_impl_.attachmentmediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentfilesha256_, lhs_arena,
+      &other->_impl_.attachmentfilesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentfileencsha256_, lhs_arena,
+      &other->_impl_.attachmentfileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentdirectpath_, lhs_arena,
+      &other->_impl_.attachmentdirectpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.attachmentjpegthumbnail_, lhs_arena,
+      &other->_impl_.attachmentjpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmenttype_)
+      + sizeof(Message_InvoiceMessage::_impl_.attachmenttype_)
+      - PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.attachmentmediakeytimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.attachmentmediakeytimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_InvoiceMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[97]);
+}
+
+// ===================================================================
+
+class Message_KeepInChatMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_KeepInChatMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Message_KeepInChatMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_keeptype(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_timestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_KeepInChatMessage::_Internal::key(const Message_KeepInChatMessage* msg) {
+  return *msg->_impl_.key_;
+}
+Message_KeepInChatMessage::Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.KeepInChatMessage)
+}
+Message_KeepInChatMessage::Message_KeepInChatMessage(const Message_KeepInChatMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_KeepInChatMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.timestampms_){}
+    , decltype(_impl_.keeptype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  ::memcpy(&_impl_.timestampms_, &from._impl_.timestampms_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.keeptype_) -
+    reinterpret_cast<char*>(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.KeepInChatMessage)
+}
+
+inline void Message_KeepInChatMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.timestampms_){int64_t{0}}
+    , decltype(_impl_.keeptype_){0}
+  };
+}
+
+Message_KeepInChatMessage::~Message_KeepInChatMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.KeepInChatMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_KeepInChatMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void Message_KeepInChatMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_KeepInChatMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.KeepInChatMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.key_ != nullptr);
+    _impl_.key_->Clear();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.timestampms_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.keeptype_) -
+        reinterpret_cast<char*>(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_KeepInChatMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.KeepType keepType = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) {
+            _internal_set_keeptype(static_cast<::proto::KeepType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 timestampMs = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_timestampms(&has_bits);
+          _impl_.timestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_KeepInChatMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.KeepInChatMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.KeepType keepType = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_keeptype(), target);
+  }
+
+  // optional int64 timestampMs = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestampms(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.KeepInChatMessage)
+  return target;
+}
+
+size_t Message_KeepInChatMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.KeepInChatMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional int64 timestampMs = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestampms());
+    }
+
+    // optional .proto.KeepType keepType = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_KeepInChatMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_KeepInChatMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_KeepInChatMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_KeepInChatMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_KeepInChatMessage*>(&to_msg);
+  auto& from = static_cast<const Message_KeepInChatMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.KeepInChatMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.timestampms_ = from._impl_.timestampms_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.keeptype_ = from._impl_.keeptype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_KeepInChatMessage::CopyFrom(const Message_KeepInChatMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.KeepInChatMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_KeepInChatMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_KeepInChatMessage::InternalSwap(Message_KeepInChatMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.keeptype_)
+      + sizeof(Message_KeepInChatMessage::_impl_.keeptype_)
+      - PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_KeepInChatMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[98]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_ProductListHeaderImage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_ProductListHeaderImage>()._impl_._has_bits_);
+  static void set_has_productid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListHeaderImage)
+}
+Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_ProductListHeaderImage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}
+    , decltype(_impl_.jpegthumbnail_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_productid()) {
+    _this->_impl_.productid_.Set(from._internal_productid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListHeaderImage)
+}
+
+inline void Message_ListMessage_ProductListHeaderImage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}
+    , decltype(_impl_.jpegthumbnail_){}
+  };
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_ProductListHeaderImage::~Message_ListMessage_ProductListHeaderImage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListHeaderImage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_ProductListHeaderImage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.productid_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+}
+
+void Message_ListMessage_ProductListHeaderImage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_ProductListHeaderImage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListHeaderImage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.productid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_ProductListHeaderImage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string productId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_productid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListHeaderImage.productId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_ProductListHeaderImage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListHeaderImage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string productId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_productid().data(), static_cast<int>(this->_internal_productid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.ProductListHeaderImage.productId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_productid(), target);
+  }
+
+  // optional bytes jpegThumbnail = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_jpegthumbnail(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.ProductListHeaderImage)
+  return target;
+}
+
+size_t Message_ListMessage_ProductListHeaderImage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListHeaderImage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string productId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_productid());
+    }
+
+    // optional bytes jpegThumbnail = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListHeaderImage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_ProductListHeaderImage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListHeaderImage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_ProductListHeaderImage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_ProductListHeaderImage*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_ProductListHeaderImage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListHeaderImage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_productid(from._internal_productid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_ProductListHeaderImage::CopyFrom(const Message_ListMessage_ProductListHeaderImage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListHeaderImage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_ProductListHeaderImage::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_ProductListHeaderImage::InternalSwap(Message_ListMessage_ProductListHeaderImage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.productid_, lhs_arena,
+      &other->_impl_.productid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListHeaderImage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[99]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_ProductListInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_ProductListInfo>()._impl_._has_bits_);
+  static const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage(const Message_ListMessage_ProductListInfo* msg);
+  static void set_has_headerimage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_businessownerjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::Message_ListMessage_ProductListHeaderImage&
+Message_ListMessage_ProductListInfo::_Internal::headerimage(const Message_ListMessage_ProductListInfo* msg) {
+  return *msg->_impl_.headerimage_;
+}
+Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListInfo)
+}
+Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_ProductListInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productsections_){from._impl_.productsections_}
+    , decltype(_impl_.businessownerjid_){}
+    , decltype(_impl_.headerimage_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.businessownerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_businessownerjid()) {
+    _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_headerimage()) {
+    _this->_impl_.headerimage_ = new ::proto::Message_ListMessage_ProductListHeaderImage(*from._impl_.headerimage_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListInfo)
+}
+
+inline void Message_ListMessage_ProductListInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productsections_){arena}
+    , decltype(_impl_.businessownerjid_){}
+    , decltype(_impl_.headerimage_){nullptr}
+  };
+  _impl_.businessownerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_ProductListInfo::~Message_ListMessage_ProductListInfo() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_ProductListInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.productsections_.~RepeatedPtrField();
+  _impl_.businessownerjid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.headerimage_;
+}
+
+void Message_ListMessage_ProductListInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_ProductListInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.productsections_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.businessownerjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.headerimage_ != nullptr);
+      _impl_.headerimage_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_ProductListInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.Message.ListMessage.ProductSection productSections = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_productsections(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_headerimage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string businessOwnerJid = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_businessownerjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListInfo.businessOwnerJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_ProductListInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ListMessage.ProductSection productSections = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_productsections_size()); i < n; i++) {
+    const auto& repfield = this->_internal_productsections(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::headerimage(this),
+        _Internal::headerimage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string businessOwnerJid = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_businessownerjid().data(), static_cast<int>(this->_internal_businessownerjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.ProductListInfo.businessOwnerJid");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_businessownerjid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.ProductListInfo)
+  return target;
+}
+
+size_t Message_ListMessage_ProductListInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ListMessage.ProductSection productSections = 1;
+  total_size += 1UL * this->_internal_productsections_size();
+  for (const auto& msg : this->_impl_.productsections_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string businessOwnerJid = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_businessownerjid());
+    }
+
+    // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.headerimage_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_ProductListInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListInfo::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_ProductListInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_ProductListInfo*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_ProductListInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.productsections_.MergeFrom(from._impl_.productsections_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_businessownerjid(from._internal_businessownerjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_headerimage()->::proto::Message_ListMessage_ProductListHeaderImage::MergeFrom(
+          from._internal_headerimage());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_ProductListInfo::CopyFrom(const Message_ListMessage_ProductListInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_ProductListInfo::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_ProductListInfo::InternalSwap(Message_ListMessage_ProductListInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.productsections_.InternalSwap(&other->_impl_.productsections_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.businessownerjid_, lhs_arena,
+      &other->_impl_.businessownerjid_, rhs_arena
+  );
+  swap(_impl_.headerimage_, other->_impl_.headerimage_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[100]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_ProductSection::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_ProductSection>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductSection)
+}
+Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_ProductSection* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.products_){from._impl_.products_}
+    , decltype(_impl_.title_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductSection)
+}
+
+inline void Message_ListMessage_ProductSection::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.products_){arena}
+    , decltype(_impl_.title_){}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_ProductSection::~Message_ListMessage_ProductSection() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductSection)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_ProductSection::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.products_.~RepeatedPtrField();
+  _impl_.title_.Destroy();
+}
+
+void Message_ListMessage_ProductSection::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_ProductSection::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductSection)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.products_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.title_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_ProductSection::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductSection.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.ListMessage.Product products = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_products(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_ProductSection::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductSection)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.ProductSection.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // repeated .proto.Message.ListMessage.Product products = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_products_size()); i < n; i++) {
+    const auto& repfield = this->_internal_products(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.ProductSection)
+  return target;
+}
+
+size_t Message_ListMessage_ProductSection::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductSection)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ListMessage.Product products = 2;
+  total_size += 1UL * this->_internal_products_size();
+  for (const auto& msg : this->_impl_.products_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional string title = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_title());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductSection::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_ProductSection::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductSection::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_ProductSection::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_ProductSection*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_ProductSection&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductSection)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.products_.MergeFrom(from._impl_.products_);
+  if (from._internal_has_title()) {
+    _this->_internal_set_title(from._internal_title());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_ProductSection::CopyFrom(const Message_ListMessage_ProductSection& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductSection)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_ProductSection::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_ProductSection::InternalSwap(Message_ListMessage_ProductSection* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.products_.InternalSwap(&other->_impl_.products_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductSection::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[101]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_Product::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_Product>()._impl_._has_bits_);
+  static void set_has_productid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_ListMessage_Product::Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Product)
+}
+Message_ListMessage_Product::Message_ListMessage_Product(const Message_ListMessage_Product& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_Product* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_productid()) {
+    _this->_impl_.productid_.Set(from._internal_productid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Product)
+}
+
+inline void Message_ListMessage_Product::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}
+  };
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_Product::~Message_ListMessage_Product() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Product)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_Product::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.productid_.Destroy();
+}
+
+void Message_ListMessage_Product::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_Product::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Product)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.productid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_Product::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string productId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_productid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Product.productId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_Product::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Product)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string productId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_productid().data(), static_cast<int>(this->_internal_productid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.Product.productId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_productid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.Product)
+  return target;
+}
+
+size_t Message_ListMessage_Product::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Product)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string productId = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_productid());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Product::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_Product::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Product::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_Product::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_Product*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_Product&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Product)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_productid()) {
+    _this->_internal_set_productid(from._internal_productid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_Product::CopyFrom(const Message_ListMessage_Product& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Product)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_Product::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_Product::InternalSwap(Message_ListMessage_Product* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.productid_, lhs_arena,
+      &other->_impl_.productid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Product::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[102]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_Row::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_Row>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_rowid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+Message_ListMessage_Row::Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Row)
+}
+Message_ListMessage_Row::Message_ListMessage_Row(const Message_ListMessage_Row& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_Row* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.rowid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.rowid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rowid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_rowid()) {
+    _this->_impl_.rowid_.Set(from._internal_rowid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Row)
+}
+
+inline void Message_ListMessage_Row::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.rowid_){}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.rowid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rowid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_Row::~Message_ListMessage_Row() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Row)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_Row::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.rowid_.Destroy();
+}
+
+void Message_ListMessage_Row::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_Row::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Row)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.rowid_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_Row::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string rowId = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_rowid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.rowId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_Row::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Row)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.Row.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // optional string description = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.Row.description");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_description(), target);
+  }
+
+  // optional string rowId = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_rowid().data(), static_cast<int>(this->_internal_rowid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.Row.rowId");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_rowid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.Row)
+  return target;
+}
+
+size_t Message_ListMessage_Row::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Row)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string title = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string rowId = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_rowid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Row::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_Row::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Row::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_Row::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_Row*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_Row&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Row)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_rowid(from._internal_rowid());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_Row::CopyFrom(const Message_ListMessage_Row& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Row)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_Row::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_Row::InternalSwap(Message_ListMessage_Row* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.rowid_, lhs_arena,
+      &other->_impl_.rowid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Row::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[103]);
+}
+
+// ===================================================================
+
+class Message_ListMessage_Section::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage_Section>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_ListMessage_Section::Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Section)
+}
+Message_ListMessage_Section::Message_ListMessage_Section(const Message_ListMessage_Section& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage_Section* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.rows_){from._impl_.rows_}
+    , decltype(_impl_.title_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Section)
+}
+
+inline void Message_ListMessage_Section::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.rows_){arena}
+    , decltype(_impl_.title_){}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage_Section::~Message_ListMessage_Section() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Section)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage_Section::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.rows_.~RepeatedPtrField();
+  _impl_.title_.Destroy();
+}
+
+void Message_ListMessage_Section::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage_Section::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Section)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.rows_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.title_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage_Section::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Section.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.ListMessage.Row rows = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_rows(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage_Section::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Section)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.Section.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // repeated .proto.Message.ListMessage.Row rows = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_rows_size()); i < n; i++) {
+    const auto& repfield = this->_internal_rows(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage.Section)
+  return target;
+}
+
+size_t Message_ListMessage_Section::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Section)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ListMessage.Row rows = 2;
+  total_size += 1UL * this->_internal_rows_size();
+  for (const auto& msg : this->_impl_.rows_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional string title = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_title());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Section::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage_Section::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Section::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage_Section::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage_Section*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage_Section&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Section)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.rows_.MergeFrom(from._impl_.rows_);
+  if (from._internal_has_title()) {
+    _this->_internal_set_title(from._internal_title());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage_Section::CopyFrom(const Message_ListMessage_Section& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Section)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage_Section::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage_Section::InternalSwap(Message_ListMessage_Section* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.rows_.InternalSwap(&other->_impl_.rows_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Section::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[104]);
+}
+
+// ===================================================================
+
+class Message_ListMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListMessage>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_buttontext(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_listtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::Message_ListMessage_ProductListInfo& productlistinfo(const Message_ListMessage* msg);
+  static void set_has_productlistinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_footertext(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ListMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+const ::proto::Message_ListMessage_ProductListInfo&
+Message_ListMessage::_Internal::productlistinfo(const Message_ListMessage* msg) {
+  return *msg->_impl_.productlistinfo_;
+}
+const ::proto::ContextInfo&
+Message_ListMessage::_Internal::contextinfo(const Message_ListMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ListMessage::Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage)
+}
+Message_ListMessage::Message_ListMessage(const Message_ListMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sections_){from._impl_.sections_}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.buttontext_){}
+    , decltype(_impl_.footertext_){}
+    , decltype(_impl_.productlistinfo_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.listtype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.buttontext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttontext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_buttontext()) {
+    _this->_impl_.buttontext_.Set(from._internal_buttontext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.footertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_footertext()) {
+    _this->_impl_.footertext_.Set(from._internal_footertext(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_productlistinfo()) {
+    _this->_impl_.productlistinfo_ = new ::proto::Message_ListMessage_ProductListInfo(*from._impl_.productlistinfo_);
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.listtype_ = from._impl_.listtype_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage)
+}
+
+inline void Message_ListMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sections_){arena}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.buttontext_){}
+    , decltype(_impl_.footertext_){}
+    , decltype(_impl_.productlistinfo_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.listtype_){0}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.buttontext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.buttontext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.footertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListMessage::~Message_ListMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.sections_.~RepeatedPtrField();
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.buttontext_.Destroy();
+  _impl_.footertext_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.productlistinfo_;
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ListMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.sections_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.buttontext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.footertext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.productlistinfo_ != nullptr);
+      _impl_.productlistinfo_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.listtype_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string buttonText = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_buttontext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.buttonText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListMessage.ListType listType = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListMessage_ListType_IsValid(val))) {
+            _internal_set_listtype(static_cast<::proto::Message_ListMessage_ListType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.ListMessage.Section sections = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_sections(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_productlistinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string footerText = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_footertext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.footerText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // optional string description = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.description");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_description(), target);
+  }
+
+  // optional string buttonText = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_buttontext().data(), static_cast<int>(this->_internal_buttontext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.buttonText");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_buttontext(), target);
+  }
+
+  // optional .proto.Message.ListMessage.ListType listType = 4;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_listtype(), target);
+  }
+
+  // repeated .proto.Message.ListMessage.Section sections = 5;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_sections_size()); i < n; i++) {
+    const auto& repfield = this->_internal_sections(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::productlistinfo(this),
+        _Internal::productlistinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string footerText = 7;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_footertext().data(), static_cast<int>(this->_internal_footertext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListMessage.footerText");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_footertext(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListMessage)
+  return target;
+}
+
+size_t Message_ListMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.ListMessage.Section sections = 5;
+  total_size += 1UL * this->_internal_sections_size();
+  for (const auto& msg : this->_impl_.sections_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional string title = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string buttonText = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_buttontext());
+    }
+
+    // optional string footerText = 7;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_footertext());
+    }
+
+    // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.productlistinfo_);
+    }
+
+    // optional .proto.ContextInfo contextInfo = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional .proto.Message.ListMessage.ListType listType = 4;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ListMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.sections_.MergeFrom(from._impl_.sections_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_buttontext(from._internal_buttontext());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_footertext(from._internal_footertext());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_productlistinfo()->::proto::Message_ListMessage_ProductListInfo::MergeFrom(
+          from._internal_productlistinfo());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.listtype_ = from._impl_.listtype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListMessage::CopyFrom(const Message_ListMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ListMessage::InternalSwap(Message_ListMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.sections_.InternalSwap(&other->_impl_.sections_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.buttontext_, lhs_arena,
+      &other->_impl_.buttontext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.footertext_, lhs_arena,
+      &other->_impl_.footertext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.listtype_)
+      + sizeof(Message_ListMessage::_impl_.listtype_)
+      - PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.productlistinfo_)>(
+          reinterpret_cast<char*>(&_impl_.productlistinfo_),
+          reinterpret_cast<char*>(&other->_impl_.productlistinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[105]);
+}
+
+// ===================================================================
+
+class Message_ListResponseMessage_SingleSelectReply::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListResponseMessage_SingleSelectReply>()._impl_._has_bits_);
+  static void set_has_selectedrowid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage.SingleSelectReply)
+}
+Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListResponseMessage_SingleSelectReply* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedrowid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.selectedrowid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_selectedrowid()) {
+    _this->_impl_.selectedrowid_.Set(from._internal_selectedrowid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage.SingleSelectReply)
+}
+
+inline void Message_ListResponseMessage_SingleSelectReply::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedrowid_){}
+  };
+  _impl_.selectedrowid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListResponseMessage_SingleSelectReply::~Message_ListResponseMessage_SingleSelectReply() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage.SingleSelectReply)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListResponseMessage_SingleSelectReply::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.selectedrowid_.Destroy();
+}
+
+void Message_ListResponseMessage_SingleSelectReply::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListResponseMessage_SingleSelectReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage.SingleSelectReply)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.selectedrowid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListResponseMessage_SingleSelectReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string selectedRowId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_selectedrowid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListResponseMessage_SingleSelectReply::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage.SingleSelectReply)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string selectedRowId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_selectedrowid().data(), static_cast<int>(this->_internal_selectedrowid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_selectedrowid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListResponseMessage.SingleSelectReply)
+  return target;
+}
+
+size_t Message_ListResponseMessage_SingleSelectReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage.SingleSelectReply)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string selectedRowId = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_selectedrowid());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage_SingleSelectReply::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListResponseMessage_SingleSelectReply::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage_SingleSelectReply::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListResponseMessage_SingleSelectReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListResponseMessage_SingleSelectReply*>(&to_msg);
+  auto& from = static_cast<const Message_ListResponseMessage_SingleSelectReply&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage.SingleSelectReply)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_selectedrowid()) {
+    _this->_internal_set_selectedrowid(from._internal_selectedrowid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListResponseMessage_SingleSelectReply::CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage.SingleSelectReply)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListResponseMessage_SingleSelectReply::IsInitialized() const {
+  return true;
+}
+
+void Message_ListResponseMessage_SingleSelectReply::InternalSwap(Message_ListResponseMessage_SingleSelectReply* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.selectedrowid_, lhs_arena,
+      &other->_impl_.selectedrowid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage_SingleSelectReply::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[106]);
+}
+
+// ===================================================================
+
+class Message_ListResponseMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ListResponseMessage>()._impl_._has_bits_);
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_listtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply(const Message_ListResponseMessage* msg);
+  static void set_has_singleselectreply(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ListResponseMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_ListResponseMessage_SingleSelectReply&
+Message_ListResponseMessage::_Internal::singleselectreply(const Message_ListResponseMessage* msg) {
+  return *msg->_impl_.singleselectreply_;
+}
+const ::proto::ContextInfo&
+Message_ListResponseMessage::_Internal::contextinfo(const Message_ListResponseMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ListResponseMessage::Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage)
+}
+Message_ListResponseMessage::Message_ListResponseMessage(const Message_ListResponseMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ListResponseMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.singleselectreply_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.listtype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_singleselectreply()) {
+    _this->_impl_.singleselectreply_ = new ::proto::Message_ListResponseMessage_SingleSelectReply(*from._impl_.singleselectreply_);
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.listtype_ = from._impl_.listtype_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage)
+}
+
+inline void Message_ListResponseMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.singleselectreply_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.listtype_){0}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ListResponseMessage::~Message_ListResponseMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ListResponseMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.singleselectreply_;
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ListResponseMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ListResponseMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.singleselectreply_ != nullptr);
+      _impl_.singleselectreply_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.listtype_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ListResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string title = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListResponseMessage.ListType listType = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListResponseMessage_ListType_IsValid(val))) {
+            _internal_set_listtype(static_cast<::proto::Message_ListResponseMessage_ListType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_singleselectreply(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ListResponseMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string title = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListResponseMessage.title");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_title(), target);
+  }
+
+  // optional .proto.Message.ListResponseMessage.ListType listType = 2;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_listtype(), target);
+  }
+
+  // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::singleselectreply(this),
+        _Internal::singleselectreply(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string description = 5;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ListResponseMessage.description");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_description(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ListResponseMessage)
+  return target;
+}
+
+size_t Message_ListResponseMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string title = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.singleselectreply_);
+    }
+
+    // optional .proto.ContextInfo contextInfo = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional .proto.Message.ListResponseMessage.ListType listType = 2;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ListResponseMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ListResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ListResponseMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ListResponseMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_singleselectreply()->::proto::Message_ListResponseMessage_SingleSelectReply::MergeFrom(
+          from._internal_singleselectreply());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.listtype_ = from._impl_.listtype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ListResponseMessage::CopyFrom(const Message_ListResponseMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ListResponseMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ListResponseMessage::InternalSwap(Message_ListResponseMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.listtype_)
+      + sizeof(Message_ListResponseMessage::_impl_.listtype_)
+      - PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.singleselectreply_)>(
+          reinterpret_cast<char*>(&_impl_.singleselectreply_),
+          reinterpret_cast<char*>(&other->_impl_.singleselectreply_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[107]);
+}
+
+// ===================================================================
+
+class Message_LiveLocationMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_LiveLocationMessage>()._impl_._has_bits_);
+  static void set_has_degreeslatitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_degreeslongitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_accuracyinmeters(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_speedinmps(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_sequencenumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_timeoffset(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_LiveLocationMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_LiveLocationMessage::_Internal::contextinfo(const Message_LiveLocationMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_LiveLocationMessage::Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.LiveLocationMessage)
+}
+Message_LiveLocationMessage::Message_LiveLocationMessage(const Message_LiveLocationMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_LiveLocationMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.degreeslatitude_){}
+    , decltype(_impl_.degreeslongitude_){}
+    , decltype(_impl_.accuracyinmeters_){}
+    , decltype(_impl_.speedinmps_){}
+    , decltype(_impl_.degreesclockwisefrommagneticnorth_){}
+    , decltype(_impl_.timeoffset_){}
+    , decltype(_impl_.sequencenumber_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sequencenumber_) -
+    reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.sequencenumber_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.LiveLocationMessage)
+}
+
+inline void Message_LiveLocationMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.degreeslatitude_){0}
+    , decltype(_impl_.degreeslongitude_){0}
+    , decltype(_impl_.accuracyinmeters_){0u}
+    , decltype(_impl_.speedinmps_){0}
+    , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u}
+    , decltype(_impl_.timeoffset_){0u}
+    , decltype(_impl_.sequencenumber_){int64_t{0}}
+  };
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_LiveLocationMessage::~Message_LiveLocationMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.LiveLocationMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_LiveLocationMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.caption_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_LiveLocationMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_LiveLocationMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.LiveLocationMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000f8u) {
+    ::memset(&_impl_.degreeslatitude_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.degreesclockwisefrommagneticnorth_) -
+        reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.timeoffset_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.sequencenumber_) -
+        reinterpret_cast<char*>(&_impl_.timeoffset_)) + sizeof(_impl_.sequencenumber_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_LiveLocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional double degreesLatitude = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
+          _Internal::set_has_degreeslatitude(&has_bits);
+          _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double degreesLongitude = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          _Internal::set_has_degreeslongitude(&has_bits);
+          _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 accuracyInMeters = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_accuracyinmeters(&has_bits);
+          _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float speedInMps = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
+          _Internal::set_has_speedinmps(&has_bits);
+          _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 degreesClockwiseFromMagneticNorth = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits);
+          _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.LiveLocationMessage.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 sequenceNumber = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_sequencenumber(&has_bits);
+          _impl_.sequencenumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 timeOffset = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_timeoffset(&has_bits);
+          _impl_.timeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_LiveLocationMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LiveLocationMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional double degreesLatitude = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target);
+  }
+
+  // optional double degreesLongitude = 2;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target);
+  }
+
+  // optional uint32 accuracyInMeters = 3;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_accuracyinmeters(), target);
+  }
+
+  // optional float speedInMps = 4;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(4, this->_internal_speedinmps(), target);
+  }
+
+  // optional uint32 degreesClockwiseFromMagneticNorth = 5;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_degreesclockwisefrommagneticnorth(), target);
+  }
+
+  // optional string caption = 6;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.LiveLocationMessage.caption");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_caption(), target);
+  }
+
+  // optional int64 sequenceNumber = 7;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_sequencenumber(), target);
+  }
+
+  // optional uint32 timeOffset = 8;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_timeoffset(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.LiveLocationMessage)
+  return target;
+}
+
+size_t Message_LiveLocationMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.LiveLocationMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string caption = 6;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional double degreesLatitude = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 8;
+    }
+
+    // optional double degreesLongitude = 2;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 8;
+    }
+
+    // optional uint32 accuracyInMeters = 3;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters());
+    }
+
+    // optional float speedInMps = 4;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 degreesClockwiseFromMagneticNorth = 5;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth());
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional uint32 timeOffset = 8;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timeoffset());
+    }
+
+    // optional int64 sequenceNumber = 7;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sequencenumber());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LiveLocationMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_LiveLocationMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LiveLocationMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_LiveLocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_LiveLocationMessage*>(&to_msg);
+  auto& from = static_cast<const Message_LiveLocationMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LiveLocationMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.speedinmps_ = from._impl_.speedinmps_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.timeoffset_ = from._impl_.timeoffset_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.sequencenumber_ = from._impl_.sequencenumber_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_LiveLocationMessage::CopyFrom(const Message_LiveLocationMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LiveLocationMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_LiveLocationMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_LiveLocationMessage::InternalSwap(Message_LiveLocationMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.sequencenumber_)
+      + sizeof(Message_LiveLocationMessage::_impl_.sequencenumber_)
+      - PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_LiveLocationMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[108]);
+}
+
+// ===================================================================
+
+class Message_LocationMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_LocationMessage>()._impl_._has_bits_);
+  static void set_has_degreeslatitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_degreeslongitude(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_address(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_islive(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_accuracyinmeters(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_speedinmps(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_comment(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_LocationMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_LocationMessage::_Internal::contextinfo(const Message_LocationMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_LocationMessage::Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.LocationMessage)
+}
+Message_LocationMessage::Message_LocationMessage(const Message_LocationMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_LocationMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.address_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.comment_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.degreeslatitude_){}
+    , decltype(_impl_.degreeslongitude_){}
+    , decltype(_impl_.islive_){}
+    , decltype(_impl_.accuracyinmeters_){}
+    , decltype(_impl_.speedinmps_){}
+    , decltype(_impl_.degreesclockwisefrommagneticnorth_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.address_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.address_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_address()) {
+    _this->_impl_.address_.Set(from._internal_address(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.comment_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_comment()) {
+    _this->_impl_.comment_.Set(from._internal_comment(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.degreesclockwisefrommagneticnorth_) -
+    reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.LocationMessage)
+}
+
+inline void Message_LocationMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.address_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.comment_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.degreeslatitude_){0}
+    , decltype(_impl_.degreeslongitude_){0}
+    , decltype(_impl_.islive_){false}
+    , decltype(_impl_.accuracyinmeters_){0u}
+    , decltype(_impl_.speedinmps_){0}
+    , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.address_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.address_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.comment_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_LocationMessage::~Message_LocationMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.LocationMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_LocationMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.address_.Destroy();
+  _impl_.url_.Destroy();
+  _impl_.comment_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_LocationMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_LocationMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.LocationMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.address_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.comment_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    ::memset(&_impl_.degreeslatitude_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.degreeslongitude_) -
+        reinterpret_cast<char*>(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_));
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    ::memset(&_impl_.islive_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.degreesclockwisefrommagneticnorth_) -
+        reinterpret_cast<char*>(&_impl_.islive_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_LocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional double degreesLatitude = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
+          _Internal::set_has_degreeslatitude(&has_bits);
+          _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double degreesLongitude = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          _Internal::set_has_degreeslongitude(&has_bits);
+          _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string address = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_address();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.address");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isLive = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_islive(&has_bits);
+          _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 accuracyInMeters = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_accuracyinmeters(&has_bits);
+          _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float speedInMps = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
+          _Internal::set_has_speedinmps(&has_bits);
+          _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 degreesClockwiseFromMagneticNorth = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits);
+          _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string comment = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_comment();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.comment");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_LocationMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LocationMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional double degreesLatitude = 1;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target);
+  }
+
+  // optional double degreesLongitude = 2;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target);
+  }
+
+  // optional string name = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.LocationMessage.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  // optional string address = 4;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_address().data(), static_cast<int>(this->_internal_address().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.LocationMessage.address");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_address(), target);
+  }
+
+  // optional string url = 5;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.LocationMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_url(), target);
+  }
+
+  // optional bool isLive = 6;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target);
+  }
+
+  // optional uint32 accuracyInMeters = 7;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_accuracyinmeters(), target);
+  }
+
+  // optional float speedInMps = 8;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(8, this->_internal_speedinmps(), target);
+  }
+
+  // optional uint32 degreesClockwiseFromMagneticNorth = 9;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_degreesclockwisefrommagneticnorth(), target);
+  }
+
+  // optional string comment = 11;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_comment().data(), static_cast<int>(this->_internal_comment().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.LocationMessage.comment");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_comment(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.LocationMessage)
+  return target;
+}
+
+size_t Message_LocationMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.LocationMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string name = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string address = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_address());
+    }
+
+    // optional string url = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string comment = 11;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_comment());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional double degreesLatitude = 1;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 8;
+    }
+
+    // optional double degreesLongitude = 2;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional bool isLive = 6;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint32 accuracyInMeters = 7;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters());
+    }
+
+    // optional float speedInMps = 8;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 degreesClockwiseFromMagneticNorth = 9;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LocationMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_LocationMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LocationMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_LocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_LocationMessage*>(&to_msg);
+  auto& from = static_cast<const Message_LocationMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LocationMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_address(from._internal_address());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_comment(from._internal_comment());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.islive_ = from._impl_.islive_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.speedinmps_ = from._impl_.speedinmps_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_LocationMessage::CopyFrom(const Message_LocationMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LocationMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_LocationMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_LocationMessage::InternalSwap(Message_LocationMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.address_, lhs_arena,
+      &other->_impl_.address_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.comment_, lhs_arena,
+      &other->_impl_.comment_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_)
+      + sizeof(Message_LocationMessage::_impl_.degreesclockwisefrommagneticnorth_)
+      - PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_LocationMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[109]);
+}
+
+// ===================================================================
+
+class Message_OrderMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_OrderMessage>()._impl_._has_bits_);
+  static void set_has_orderid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_thumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_itemcount(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_status(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_surface(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_ordertitle(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_sellerjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_totalamount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_totalcurrencycode(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_OrderMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_OrderMessage::_Internal::contextinfo(const Message_OrderMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_OrderMessage::Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.OrderMessage)
+}
+Message_OrderMessage::Message_OrderMessage(const Message_OrderMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_OrderMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.orderid_){}
+    , decltype(_impl_.thumbnail_){}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.ordertitle_){}
+    , decltype(_impl_.sellerjid_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.totalcurrencycode_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.totalamount1000_){}
+    , decltype(_impl_.itemcount_){}
+    , decltype(_impl_.status_){}
+    , decltype(_impl_.surface_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.orderid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.orderid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_orderid()) {
+    _this->_impl_.orderid_.Set(from._internal_orderid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnail()) {
+    _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_message()) {
+    _this->_impl_.message_.Set(from._internal_message(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.ordertitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ordertitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ordertitle()) {
+    _this->_impl_.ordertitle_.Set(from._internal_ordertitle(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.sellerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sellerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sellerjid()) {
+    _this->_impl_.sellerjid_.Set(from._internal_sellerjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.totalcurrencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_totalcurrencycode()) {
+    _this->_impl_.totalcurrencycode_.Set(from._internal_totalcurrencycode(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.totalamount1000_, &from._impl_.totalamount1000_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.surface_) -
+    reinterpret_cast<char*>(&_impl_.totalamount1000_)) + sizeof(_impl_.surface_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.OrderMessage)
+}
+
+inline void Message_OrderMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.orderid_){}
+    , decltype(_impl_.thumbnail_){}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.ordertitle_){}
+    , decltype(_impl_.sellerjid_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.totalcurrencycode_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.totalamount1000_){int64_t{0}}
+    , decltype(_impl_.itemcount_){0}
+    , decltype(_impl_.status_){1}
+    , decltype(_impl_.surface_){1}
+  };
+  _impl_.orderid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.orderid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.ordertitle_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ordertitle_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.sellerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sellerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.totalcurrencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_OrderMessage::~Message_OrderMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.OrderMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_OrderMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.orderid_.Destroy();
+  _impl_.thumbnail_.Destroy();
+  _impl_.message_.Destroy();
+  _impl_.ordertitle_.Destroy();
+  _impl_.sellerjid_.Destroy();
+  _impl_.token_.Destroy();
+  _impl_.totalcurrencycode_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_OrderMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_OrderMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.OrderMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.orderid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.thumbnail_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.message_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.ordertitle_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.sellerjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.totalcurrencycode_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    ::memset(&_impl_.totalamount1000_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.itemcount_) -
+        reinterpret_cast<char*>(&_impl_.totalamount1000_)) + sizeof(_impl_.itemcount_));
+    _impl_.status_ = 1;
+    _impl_.surface_ = 1;
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_OrderMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string orderId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_orderid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnail = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_thumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 itemCount = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_itemcount(&has_bits);
+          _impl_.itemcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.OrderMessage.OrderStatus status = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderStatus_IsValid(val))) {
+            _internal_set_status(static_cast<::proto::Message_OrderMessage_OrderStatus>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.OrderMessage.OrderSurface surface = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderSurface_IsValid(val))) {
+            _internal_set_surface(static_cast<::proto::Message_OrderMessage_OrderSurface>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string message = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_message();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.message");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string orderTitle = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_ordertitle();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderTitle");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string sellerJid = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_sellerjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.sellerJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string token = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.token");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 totalAmount1000 = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_totalamount1000(&has_bits);
+          _impl_.totalamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string totalCurrencyCode = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_totalcurrencycode();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.totalCurrencyCode");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_OrderMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.OrderMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string orderId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_orderid().data(), static_cast<int>(this->_internal_orderid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.orderId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_orderid(), target);
+  }
+
+  // optional bytes thumbnail = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_thumbnail(), target);
+  }
+
+  // optional int32 itemCount = 3;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_itemcount(), target);
+  }
+
+  // optional .proto.Message.OrderMessage.OrderStatus status = 4;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_status(), target);
+  }
+
+  // optional .proto.Message.OrderMessage.OrderSurface surface = 5;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_surface(), target);
+  }
+
+  // optional string message = 6;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.message");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_message(), target);
+  }
+
+  // optional string orderTitle = 7;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_ordertitle().data(), static_cast<int>(this->_internal_ordertitle().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.orderTitle");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_ordertitle(), target);
+  }
+
+  // optional string sellerJid = 8;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_sellerjid().data(), static_cast<int>(this->_internal_sellerjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.sellerJid");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_sellerjid(), target);
+  }
+
+  // optional string token = 9;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_token().data(), static_cast<int>(this->_internal_token().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.token");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_token(), target);
+  }
+
+  // optional int64 totalAmount1000 = 10;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_totalamount1000(), target);
+  }
+
+  // optional string totalCurrencyCode = 11;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_totalcurrencycode().data(), static_cast<int>(this->_internal_totalcurrencycode().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.OrderMessage.totalCurrencyCode");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_totalcurrencycode(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.OrderMessage)
+  return target;
+}
+
+size_t Message_OrderMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.OrderMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string orderId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_orderid());
+    }
+
+    // optional bytes thumbnail = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnail());
+    }
+
+    // optional string message = 6;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_message());
+    }
+
+    // optional string orderTitle = 7;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_ordertitle());
+    }
+
+    // optional string sellerJid = 8;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_sellerjid());
+    }
+
+    // optional string token = 9;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_token());
+    }
+
+    // optional string totalCurrencyCode = 11;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_totalcurrencycode());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional int64 totalAmount1000 = 10;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_totalamount1000());
+    }
+
+    // optional int32 itemCount = 3;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_itemcount());
+    }
+
+    // optional .proto.Message.OrderMessage.OrderStatus status = 4;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
+    }
+
+    // optional .proto.Message.OrderMessage.OrderSurface surface = 5;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_surface());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_OrderMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_OrderMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_OrderMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_OrderMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_OrderMessage*>(&to_msg);
+  auto& from = static_cast<const Message_OrderMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.OrderMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_orderid(from._internal_orderid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_thumbnail(from._internal_thumbnail());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_message(from._internal_message());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_ordertitle(from._internal_ordertitle());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_sellerjid(from._internal_sellerjid());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_totalcurrencycode(from._internal_totalcurrencycode());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.totalamount1000_ = from._impl_.totalamount1000_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.itemcount_ = from._impl_.itemcount_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.status_ = from._impl_.status_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.surface_ = from._impl_.surface_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_OrderMessage::CopyFrom(const Message_OrderMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.OrderMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_OrderMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_OrderMessage::InternalSwap(Message_OrderMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.orderid_, lhs_arena,
+      &other->_impl_.orderid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnail_, lhs_arena,
+      &other->_impl_.thumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.message_, lhs_arena,
+      &other->_impl_.message_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ordertitle_, lhs_arena,
+      &other->_impl_.ordertitle_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sellerjid_, lhs_arena,
+      &other->_impl_.sellerjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.totalcurrencycode_, lhs_arena,
+      &other->_impl_.totalcurrencycode_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.itemcount_)
+      + sizeof(Message_OrderMessage::_impl_.itemcount_)
+      - PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+  swap(_impl_.status_, other->_impl_.status_);
+  swap(_impl_.surface_, other->_impl_.surface_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_OrderMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[110]);
+}
+
+// ===================================================================
+
+class Message_PaymentInviteMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_PaymentInviteMessage>()._impl_._has_bits_);
+  static void set_has_servicetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_expirytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_PaymentInviteMessage::Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PaymentInviteMessage)
+}
+Message_PaymentInviteMessage::Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PaymentInviteMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expirytimestamp_){}
+    , decltype(_impl_.servicetype_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.expirytimestamp_, &from._impl_.expirytimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.servicetype_) -
+    reinterpret_cast<char*>(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PaymentInviteMessage)
+}
+
+inline void Message_PaymentInviteMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expirytimestamp_){int64_t{0}}
+    , decltype(_impl_.servicetype_){0}
+  };
+}
+
+Message_PaymentInviteMessage::~Message_PaymentInviteMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.PaymentInviteMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PaymentInviteMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Message_PaymentInviteMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PaymentInviteMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PaymentInviteMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.expirytimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.servicetype_) -
+        reinterpret_cast<char*>(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PaymentInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(val))) {
+            _internal_set_servicetype(static_cast<::proto::Message_PaymentInviteMessage_ServiceType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 expiryTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_expirytimestamp(&has_bits);
+          _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PaymentInviteMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PaymentInviteMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_servicetype(), target);
+  }
+
+  // optional int64 expiryTimestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_expirytimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PaymentInviteMessage)
+  return target;
+}
+
+size_t Message_PaymentInviteMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PaymentInviteMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional int64 expiryTimestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp());
+    }
+
+    // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_servicetype());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PaymentInviteMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PaymentInviteMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PaymentInviteMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_PaymentInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PaymentInviteMessage*>(&to_msg);
+  auto& from = static_cast<const Message_PaymentInviteMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PaymentInviteMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.servicetype_ = from._impl_.servicetype_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PaymentInviteMessage::CopyFrom(const Message_PaymentInviteMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PaymentInviteMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PaymentInviteMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_PaymentInviteMessage::InternalSwap(Message_PaymentInviteMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.servicetype_)
+      + sizeof(Message_PaymentInviteMessage::_impl_.servicetype_)
+      - PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.expirytimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.expirytimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.expirytimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PaymentInviteMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[111]);
+}
+
+// ===================================================================
+
+class Message_PollCreationMessage_Option::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_PollCreationMessage_Option>()._impl_._has_bits_);
+  static void set_has_optionname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage.Option)
+}
+Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PollCreationMessage_Option* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.optionname_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.optionname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optionname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_optionname()) {
+    _this->_impl_.optionname_.Set(from._internal_optionname(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage.Option)
+}
+
+inline void Message_PollCreationMessage_Option::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.optionname_){}
+  };
+  _impl_.optionname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optionname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_PollCreationMessage_Option::~Message_PollCreationMessage_Option() {
+  // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage.Option)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PollCreationMessage_Option::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.optionname_.Destroy();
+}
+
+void Message_PollCreationMessage_Option::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PollCreationMessage_Option::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage.Option)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.optionname_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PollCreationMessage_Option::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string optionName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_optionname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.Option.optionName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PollCreationMessage_Option::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage.Option)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string optionName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_optionname().data(), static_cast<int>(this->_internal_optionname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.PollCreationMessage.Option.optionName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_optionname(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PollCreationMessage.Option)
+  return target;
+}
+
+size_t Message_PollCreationMessage_Option::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage.Option)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string optionName = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_optionname());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage_Option::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PollCreationMessage_Option::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage_Option::GetClassData() const { return &_class_data_; }
+
+
+void Message_PollCreationMessage_Option::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PollCreationMessage_Option*>(&to_msg);
+  auto& from = static_cast<const Message_PollCreationMessage_Option&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage.Option)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_optionname()) {
+    _this->_internal_set_optionname(from._internal_optionname());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PollCreationMessage_Option::CopyFrom(const Message_PollCreationMessage_Option& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage.Option)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PollCreationMessage_Option::IsInitialized() const {
+  return true;
+}
+
+void Message_PollCreationMessage_Option::InternalSwap(Message_PollCreationMessage_Option* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.optionname_, lhs_arena,
+      &other->_impl_.optionname_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage_Option::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[112]);
+}
+
+// ===================================================================
+
+class Message_PollCreationMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_PollCreationMessage>()._impl_._has_bits_);
+  static void set_has_enckey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_selectableoptionscount(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_PollCreationMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_PollCreationMessage::_Internal::contextinfo(const Message_PollCreationMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_PollCreationMessage::Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage)
+}
+Message_PollCreationMessage::Message_PollCreationMessage(const Message_PollCreationMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PollCreationMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.options_){from._impl_.options_}
+    , decltype(_impl_.enckey_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.selectableoptionscount_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.enckey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enckey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_enckey()) {
+    _this->_impl_.enckey_.Set(from._internal_enckey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage)
+}
+
+inline void Message_PollCreationMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.options_){arena}
+    , decltype(_impl_.enckey_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.selectableoptionscount_){0u}
+  };
+  _impl_.enckey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enckey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_PollCreationMessage::~Message_PollCreationMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PollCreationMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.options_.~RepeatedPtrField();
+  _impl_.enckey_.Destroy();
+  _impl_.name_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_PollCreationMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PollCreationMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.options_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.enckey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.selectableoptionscount_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PollCreationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes encKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_enckey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string name = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.PollCreationMessage.Option options = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_options(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 selectableOptionsCount = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_selectableoptionscount(&has_bits);
+          _impl_.selectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PollCreationMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes encKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_enckey(), target);
+  }
+
+  // optional string name = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.PollCreationMessage.name");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_name(), target);
+  }
+
+  // repeated .proto.Message.PollCreationMessage.Option options = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_options_size()); i < n; i++) {
+    const auto& repfield = this->_internal_options(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 selectableOptionsCount = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectableoptionscount(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PollCreationMessage)
+  return target;
+}
+
+size_t Message_PollCreationMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.PollCreationMessage.Option options = 3;
+  total_size += 1UL * this->_internal_options_size();
+  for (const auto& msg : this->_impl_.options_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes encKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_enckey());
+    }
+
+    // optional string name = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint32 selectableOptionsCount = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectableoptionscount());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PollCreationMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_PollCreationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PollCreationMessage*>(&to_msg);
+  auto& from = static_cast<const Message_PollCreationMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.options_.MergeFrom(from._impl_.options_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_enckey(from._internal_enckey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PollCreationMessage::CopyFrom(const Message_PollCreationMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PollCreationMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_PollCreationMessage::InternalSwap(Message_PollCreationMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.options_.InternalSwap(&other->_impl_.options_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.enckey_, lhs_arena,
+      &other->_impl_.enckey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.selectableoptionscount_)
+      + sizeof(Message_PollCreationMessage::_impl_.selectableoptionscount_)
+      - PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[113]);
+}
+
+// ===================================================================
+
+class Message_PollEncValue::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_PollEncValue>()._impl_._has_bits_);
+  static void set_has_encpayload(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_enciv(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_PollEncValue::Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollEncValue)
+}
+Message_PollEncValue::Message_PollEncValue(const Message_PollEncValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PollEncValue* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.encpayload_){}
+    , decltype(_impl_.enciv_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.encpayload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_encpayload()) {
+    _this->_impl_.encpayload_.Set(from._internal_encpayload(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.enciv_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_enciv()) {
+    _this->_impl_.enciv_.Set(from._internal_enciv(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollEncValue)
+}
+
+inline void Message_PollEncValue::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.encpayload_){}
+    , decltype(_impl_.enciv_){}
+  };
+  _impl_.encpayload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.enciv_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_PollEncValue::~Message_PollEncValue() {
+  // @@protoc_insertion_point(destructor:proto.Message.PollEncValue)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PollEncValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.encpayload_.Destroy();
+  _impl_.enciv_.Destroy();
+}
+
+void Message_PollEncValue::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PollEncValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PollEncValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.encpayload_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.enciv_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes encPayload = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_encpayload();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes encIv = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_enciv();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PollEncValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollEncValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes encPayload = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_encpayload(), target);
+  }
+
+  // optional bytes encIv = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_enciv(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PollEncValue)
+  return target;
+}
+
+size_t Message_PollEncValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollEncValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes encPayload = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_encpayload());
+    }
+
+    // optional bytes encIv = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_enciv());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollEncValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PollEncValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollEncValue::GetClassData() const { return &_class_data_; }
+
+
+void Message_PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PollEncValue*>(&to_msg);
+  auto& from = static_cast<const Message_PollEncValue&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollEncValue)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_encpayload(from._internal_encpayload());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_enciv(from._internal_enciv());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PollEncValue::CopyFrom(const Message_PollEncValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollEncValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PollEncValue::IsInitialized() const {
+  return true;
+}
+
+void Message_PollEncValue::InternalSwap(Message_PollEncValue* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.encpayload_, lhs_arena,
+      &other->_impl_.encpayload_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.enciv_, lhs_arena,
+      &other->_impl_.enciv_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollEncValue::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[114]);
+}
+
+// ===================================================================
+
+class Message_PollUpdateMessageMetadata::_Internal {
+ public:
+};
+
+Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessageMetadata)
+}
+Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  Message_PollUpdateMessageMetadata* const _this = this; (void)_this;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessageMetadata)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessageMetadata::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessageMetadata::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessageMetadata::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[115]);
+}
+
+// ===================================================================
+
+class Message_PollUpdateMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_PollUpdateMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& pollcreationmessagekey(const Message_PollUpdateMessage* msg);
+  static void set_has_pollcreationmessagekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_PollEncValue& vote(const Message_PollUpdateMessage* msg);
+  static void set_has_vote(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_PollUpdateMessageMetadata& metadata(const Message_PollUpdateMessage* msg);
+  static void set_has_metadata(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_sendertimestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_PollUpdateMessage::_Internal::pollcreationmessagekey(const Message_PollUpdateMessage* msg) {
+  return *msg->_impl_.pollcreationmessagekey_;
+}
+const ::proto::Message_PollEncValue&
+Message_PollUpdateMessage::_Internal::vote(const Message_PollUpdateMessage* msg) {
+  return *msg->_impl_.vote_;
+}
+const ::proto::Message_PollUpdateMessageMetadata&
+Message_PollUpdateMessage::_Internal::metadata(const Message_PollUpdateMessage* msg) {
+  return *msg->_impl_.metadata_;
+}
+Message_PollUpdateMessage::Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessage)
+}
+Message_PollUpdateMessage::Message_PollUpdateMessage(const Message_PollUpdateMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PollUpdateMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollcreationmessagekey_){nullptr}
+    , decltype(_impl_.vote_){nullptr}
+    , decltype(_impl_.metadata_){nullptr}
+    , decltype(_impl_.sendertimestampms_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_pollcreationmessagekey()) {
+    _this->_impl_.pollcreationmessagekey_ = new ::proto::MessageKey(*from._impl_.pollcreationmessagekey_);
+  }
+  if (from._internal_has_vote()) {
+    _this->_impl_.vote_ = new ::proto::Message_PollEncValue(*from._impl_.vote_);
+  }
+  if (from._internal_has_metadata()) {
+    _this->_impl_.metadata_ = new ::proto::Message_PollUpdateMessageMetadata(*from._impl_.metadata_);
+  }
+  _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessage)
+}
+
+inline void Message_PollUpdateMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollcreationmessagekey_){nullptr}
+    , decltype(_impl_.vote_){nullptr}
+    , decltype(_impl_.metadata_){nullptr}
+    , decltype(_impl_.sendertimestampms_){int64_t{0}}
+  };
+}
+
+Message_PollUpdateMessage::~Message_PollUpdateMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.PollUpdateMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PollUpdateMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.pollcreationmessagekey_;
+  if (this != internal_default_instance()) delete _impl_.vote_;
+  if (this != internal_default_instance()) delete _impl_.metadata_;
+}
+
+void Message_PollUpdateMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PollUpdateMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PollUpdateMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.pollcreationmessagekey_ != nullptr);
+      _impl_.pollcreationmessagekey_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.vote_ != nullptr);
+      _impl_.vote_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.metadata_ != nullptr);
+      _impl_.metadata_->Clear();
+    }
+  }
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PollUpdateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey pollCreationMessageKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessagekey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PollEncValue vote = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_metadata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 senderTimestampMs = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_sendertimestampms(&has_bits);
+          _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PollUpdateMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollUpdateMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey pollCreationMessageKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::pollcreationmessagekey(this),
+        _Internal::pollcreationmessagekey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PollEncValue vote = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::vote(this),
+        _Internal::vote(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::metadata(this),
+        _Internal::metadata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 senderTimestampMs = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PollUpdateMessage)
+  return target;
+}
+
+size_t Message_PollUpdateMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollUpdateMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional .proto.MessageKey pollCreationMessageKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pollcreationmessagekey_);
+    }
+
+    // optional .proto.Message.PollEncValue vote = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.vote_);
+    }
+
+    // optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.metadata_);
+    }
+
+    // optional int64 senderTimestampMs = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PollUpdateMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_PollUpdateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PollUpdateMessage*>(&to_msg);
+  auto& from = static_cast<const Message_PollUpdateMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollUpdateMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_pollcreationmessagekey()->::proto::MessageKey::MergeFrom(
+          from._internal_pollcreationmessagekey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_vote()->::proto::Message_PollEncValue::MergeFrom(
+          from._internal_vote());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_metadata()->::proto::Message_PollUpdateMessageMetadata::MergeFrom(
+          from._internal_metadata());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PollUpdateMessage::CopyFrom(const Message_PollUpdateMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollUpdateMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PollUpdateMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_PollUpdateMessage::InternalSwap(Message_PollUpdateMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.sendertimestampms_)
+      + sizeof(Message_PollUpdateMessage::_impl_.sendertimestampms_)
+      - PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.pollcreationmessagekey_)>(
+          reinterpret_cast<char*>(&_impl_.pollcreationmessagekey_),
+          reinterpret_cast<char*>(&other->_impl_.pollcreationmessagekey_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[116]);
+}
+
+// ===================================================================
+
+class Message_PollVoteMessage::_Internal {
+ public:
+};
+
+Message_PollVoteMessage::Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.PollVoteMessage)
+}
+Message_PollVoteMessage::Message_PollVoteMessage(const Message_PollVoteMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_PollVoteMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.selectedoptions_){from._impl_.selectedoptions_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.Message.PollVoteMessage)
+}
+
+inline void Message_PollVoteMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.selectedoptions_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Message_PollVoteMessage::~Message_PollVoteMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.PollVoteMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_PollVoteMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.selectedoptions_.~RepeatedPtrField();
+}
+
+void Message_PollVoteMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_PollVoteMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.PollVoteMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.selectedoptions_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_PollVoteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated bytes selectedOptions = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_selectedoptions();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_PollVoteMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollVoteMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated bytes selectedOptions = 1;
+  for (int i = 0, n = this->_internal_selectedoptions_size(); i < n; i++) {
+    const auto& s = this->_internal_selectedoptions(i);
+    target = stream->WriteBytes(1, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.PollVoteMessage)
+  return target;
+}
+
+size_t Message_PollVoteMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollVoteMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated bytes selectedOptions = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.selectedoptions_.size());
+  for (int i = 0, n = _impl_.selectedoptions_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.selectedoptions_.Get(i));
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollVoteMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_PollVoteMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollVoteMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_PollVoteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_PollVoteMessage*>(&to_msg);
+  auto& from = static_cast<const Message_PollVoteMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollVoteMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.selectedoptions_.MergeFrom(from._impl_.selectedoptions_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_PollVoteMessage::CopyFrom(const Message_PollVoteMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollVoteMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_PollVoteMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_PollVoteMessage::InternalSwap(Message_PollVoteMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.selectedoptions_.InternalSwap(&other->_impl_.selectedoptions_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_PollVoteMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[117]);
+}
+
+// ===================================================================
+
+class Message_ProductMessage_CatalogSnapshot::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ProductMessage_CatalogSnapshot>()._impl_._has_bits_);
+  static const ::proto::Message_ImageMessage& catalogimage(const Message_ProductMessage_CatalogSnapshot* msg);
+  static void set_has_catalogimage(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_ImageMessage&
+Message_ProductMessage_CatalogSnapshot::_Internal::catalogimage(const Message_ProductMessage_CatalogSnapshot* msg) {
+  return *msg->_impl_.catalogimage_;
+}
+Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.CatalogSnapshot)
+}
+Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ProductMessage_CatalogSnapshot* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.catalogimage_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_catalogimage()) {
+    _this->_impl_.catalogimage_ = new ::proto::Message_ImageMessage(*from._impl_.catalogimage_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.CatalogSnapshot)
+}
+
+inline void Message_ProductMessage_CatalogSnapshot::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.catalogimage_){nullptr}
+  };
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ProductMessage_CatalogSnapshot::~Message_ProductMessage_CatalogSnapshot() {
+  // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.CatalogSnapshot)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ProductMessage_CatalogSnapshot::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.catalogimage_;
+}
+
+void Message_ProductMessage_CatalogSnapshot::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ProductMessage_CatalogSnapshot::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.CatalogSnapshot)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.catalogimage_ != nullptr);
+      _impl_.catalogimage_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ProductMessage_CatalogSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.ImageMessage catalogImage = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_catalogimage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string title = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ProductMessage_CatalogSnapshot::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.CatalogSnapshot)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.ImageMessage catalogImage = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::catalogimage(this),
+        _Internal::catalogimage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string title = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.CatalogSnapshot.title");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_title(), target);
+  }
+
+  // optional string description = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.CatalogSnapshot.description");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_description(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ProductMessage.CatalogSnapshot)
+  return target;
+}
+
+size_t Message_ProductMessage_CatalogSnapshot::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.CatalogSnapshot)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string title = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional .proto.Message.ImageMessage catalogImage = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.catalogimage_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_CatalogSnapshot::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ProductMessage_CatalogSnapshot::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_CatalogSnapshot::GetClassData() const { return &_class_data_; }
+
+
+void Message_ProductMessage_CatalogSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ProductMessage_CatalogSnapshot*>(&to_msg);
+  auto& from = static_cast<const Message_ProductMessage_CatalogSnapshot&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.CatalogSnapshot)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_catalogimage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_catalogimage());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ProductMessage_CatalogSnapshot::CopyFrom(const Message_ProductMessage_CatalogSnapshot& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.CatalogSnapshot)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ProductMessage_CatalogSnapshot::IsInitialized() const {
+  return true;
+}
+
+void Message_ProductMessage_CatalogSnapshot::InternalSwap(Message_ProductMessage_CatalogSnapshot* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  swap(_impl_.catalogimage_, other->_impl_.catalogimage_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_CatalogSnapshot::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[118]);
+}
+
+// ===================================================================
+
+class Message_ProductMessage_ProductSnapshot::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ProductMessage_ProductSnapshot>()._impl_._has_bits_);
+  static const ::proto::Message_ImageMessage& productimage(const Message_ProductMessage_ProductSnapshot* msg);
+  static void set_has_productimage(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_productid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_currencycode(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_priceamount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_retailerid(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_productimagecount(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_firstimageid(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_salepriceamount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+const ::proto::Message_ImageMessage&
+Message_ProductMessage_ProductSnapshot::_Internal::productimage(const Message_ProductMessage_ProductSnapshot* msg) {
+  return *msg->_impl_.productimage_;
+}
+Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.ProductSnapshot)
+}
+Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ProductMessage_ProductSnapshot* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.retailerid_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.firstimageid_){}
+    , decltype(_impl_.productimage_){nullptr}
+    , decltype(_impl_.priceamount1000_){}
+    , decltype(_impl_.salepriceamount1000_){}
+    , decltype(_impl_.productimagecount_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_productid()) {
+    _this->_impl_.productid_.Set(from._internal_productid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_currencycode()) {
+    _this->_impl_.currencycode_.Set(from._internal_currencycode(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.retailerid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.retailerid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_retailerid()) {
+    _this->_impl_.retailerid_.Set(from._internal_retailerid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.firstimageid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstimageid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_firstimageid()) {
+    _this->_impl_.firstimageid_.Set(from._internal_firstimageid(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_productimage()) {
+    _this->_impl_.productimage_ = new ::proto::Message_ImageMessage(*from._impl_.productimage_);
+  }
+  ::memcpy(&_impl_.priceamount1000_, &from._impl_.priceamount1000_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.productimagecount_) -
+    reinterpret_cast<char*>(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.ProductSnapshot)
+}
+
+inline void Message_ProductMessage_ProductSnapshot::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.productid_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.retailerid_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.firstimageid_){}
+    , decltype(_impl_.productimage_){nullptr}
+    , decltype(_impl_.priceamount1000_){int64_t{0}}
+    , decltype(_impl_.salepriceamount1000_){int64_t{0}}
+    , decltype(_impl_.productimagecount_){0u}
+  };
+  _impl_.productid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.retailerid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.retailerid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.firstimageid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstimageid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ProductMessage_ProductSnapshot::~Message_ProductMessage_ProductSnapshot() {
+  // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.ProductSnapshot)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ProductMessage_ProductSnapshot::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.productid_.Destroy();
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.currencycode_.Destroy();
+  _impl_.retailerid_.Destroy();
+  _impl_.url_.Destroy();
+  _impl_.firstimageid_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.productimage_;
+}
+
+void Message_ProductMessage_ProductSnapshot::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ProductMessage_ProductSnapshot::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.ProductSnapshot)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.productid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.currencycode_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.retailerid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.firstimageid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.productimage_ != nullptr);
+      _impl_.productimage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000700u) {
+    ::memset(&_impl_.priceamount1000_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.productimagecount_) -
+        reinterpret_cast<char*>(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ProductMessage_ProductSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.ImageMessage productImage = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_productimage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string productId = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_productid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.productId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string title = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string currencyCode = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_currencycode();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.currencyCode");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 priceAmount1000 = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_priceamount1000(&has_bits);
+          _impl_.priceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string retailerId = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_retailerid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.retailerId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 productImageCount = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_productimagecount(&has_bits);
+          _impl_.productimagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string firstImageId = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_firstimageid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.firstImageId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 salePriceAmount1000 = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_salepriceamount1000(&has_bits);
+          _impl_.salepriceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ProductMessage_ProductSnapshot::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.ProductSnapshot)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.ImageMessage productImage = 1;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::productimage(this),
+        _Internal::productimage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string productId = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_productid().data(), static_cast<int>(this->_internal_productid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.productId");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_productid(), target);
+  }
+
+  // optional string title = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.title");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_title(), target);
+  }
+
+  // optional string description = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.description");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_description(), target);
+  }
+
+  // optional string currencyCode = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_currencycode().data(), static_cast<int>(this->_internal_currencycode().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.currencyCode");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_currencycode(), target);
+  }
+
+  // optional int64 priceAmount1000 = 6;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_priceamount1000(), target);
+  }
+
+  // optional string retailerId = 7;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_retailerid().data(), static_cast<int>(this->_internal_retailerid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.retailerId");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_retailerid(), target);
+  }
+
+  // optional string url = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.url");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_url(), target);
+  }
+
+  // optional uint32 productImageCount = 9;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_productimagecount(), target);
+  }
+
+  // optional string firstImageId = 11;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_firstimageid().data(), static_cast<int>(this->_internal_firstimageid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.ProductSnapshot.firstImageId");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_firstimageid(), target);
+  }
+
+  // optional int64 salePriceAmount1000 = 12;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_salepriceamount1000(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ProductMessage.ProductSnapshot)
+  return target;
+}
+
+size_t Message_ProductMessage_ProductSnapshot::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.ProductSnapshot)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string productId = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_productid());
+    }
+
+    // optional string title = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string currencyCode = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_currencycode());
+    }
+
+    // optional string retailerId = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_retailerid());
+    }
+
+    // optional string url = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string firstImageId = 11;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_firstimageid());
+    }
+
+    // optional .proto.Message.ImageMessage productImage = 1;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.productimage_);
+    }
+
+  }
+  if (cached_has_bits & 0x00000700u) {
+    // optional int64 priceAmount1000 = 6;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_priceamount1000());
+    }
+
+    // optional int64 salePriceAmount1000 = 12;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_salepriceamount1000());
+    }
+
+    // optional uint32 productImageCount = 9;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_productimagecount());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_ProductSnapshot::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ProductMessage_ProductSnapshot::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_ProductSnapshot::GetClassData() const { return &_class_data_; }
+
+
+void Message_ProductMessage_ProductSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ProductMessage_ProductSnapshot*>(&to_msg);
+  auto& from = static_cast<const Message_ProductMessage_ProductSnapshot&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.ProductSnapshot)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_productid(from._internal_productid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_currencycode(from._internal_currencycode());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_retailerid(from._internal_retailerid());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_firstimageid(from._internal_firstimageid());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_productimage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_productimage());
+    }
+  }
+  if (cached_has_bits & 0x00000700u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.priceamount1000_ = from._impl_.priceamount1000_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.salepriceamount1000_ = from._impl_.salepriceamount1000_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.productimagecount_ = from._impl_.productimagecount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ProductMessage_ProductSnapshot::CopyFrom(const Message_ProductMessage_ProductSnapshot& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.ProductSnapshot)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ProductMessage_ProductSnapshot::IsInitialized() const {
+  return true;
+}
+
+void Message_ProductMessage_ProductSnapshot::InternalSwap(Message_ProductMessage_ProductSnapshot* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.productid_, lhs_arena,
+      &other->_impl_.productid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.currencycode_, lhs_arena,
+      &other->_impl_.currencycode_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.retailerid_, lhs_arena,
+      &other->_impl_.retailerid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.firstimageid_, lhs_arena,
+      &other->_impl_.firstimageid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_)
+      + sizeof(Message_ProductMessage_ProductSnapshot::_impl_.productimagecount_)
+      - PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimage_)>(
+          reinterpret_cast<char*>(&_impl_.productimage_),
+          reinterpret_cast<char*>(&other->_impl_.productimage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_ProductSnapshot::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[119]);
+}
+
+// ===================================================================
+
+class Message_ProductMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ProductMessage>()._impl_._has_bits_);
+  static const ::proto::Message_ProductMessage_ProductSnapshot& product(const Message_ProductMessage* msg);
+  static void set_has_product(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_businessownerjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_ProductMessage_CatalogSnapshot& catalog(const Message_ProductMessage* msg);
+  static void set_has_catalog(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_footer(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_ProductMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+const ::proto::Message_ProductMessage_ProductSnapshot&
+Message_ProductMessage::_Internal::product(const Message_ProductMessage* msg) {
+  return *msg->_impl_.product_;
+}
+const ::proto::Message_ProductMessage_CatalogSnapshot&
+Message_ProductMessage::_Internal::catalog(const Message_ProductMessage* msg) {
+  return *msg->_impl_.catalog_;
+}
+const ::proto::ContextInfo&
+Message_ProductMessage::_Internal::contextinfo(const Message_ProductMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_ProductMessage::Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage)
+}
+Message_ProductMessage::Message_ProductMessage(const Message_ProductMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ProductMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.businessownerjid_){}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.footer_){}
+    , decltype(_impl_.product_){nullptr}
+    , decltype(_impl_.catalog_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.businessownerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_businessownerjid()) {
+    _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.footer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_footer()) {
+    _this->_impl_.footer_.Set(from._internal_footer(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_product()) {
+    _this->_impl_.product_ = new ::proto::Message_ProductMessage_ProductSnapshot(*from._impl_.product_);
+  }
+  if (from._internal_has_catalog()) {
+    _this->_impl_.catalog_ = new ::proto::Message_ProductMessage_CatalogSnapshot(*from._impl_.catalog_);
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage)
+}
+
+inline void Message_ProductMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.businessownerjid_){}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.footer_){}
+    , decltype(_impl_.product_){nullptr}
+    , decltype(_impl_.catalog_){nullptr}
+    , decltype(_impl_.contextinfo_){nullptr}
+  };
+  _impl_.businessownerjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.footer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.footer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ProductMessage::~Message_ProductMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ProductMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ProductMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.businessownerjid_.Destroy();
+  _impl_.body_.Destroy();
+  _impl_.footer_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.product_;
+  if (this != internal_default_instance()) delete _impl_.catalog_;
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_ProductMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ProductMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.businessownerjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.body_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.footer_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.product_ != nullptr);
+      _impl_.product_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.catalog_ != nullptr);
+      _impl_.catalog_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ProductMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_product(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string businessOwnerJid = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_businessownerjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.businessOwnerJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_catalog(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string body = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.body");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string footer = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_footer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.footer");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ProductMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::product(this),
+        _Internal::product(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string businessOwnerJid = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_businessownerjid().data(), static_cast<int>(this->_internal_businessownerjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.businessOwnerJid");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_businessownerjid(), target);
+  }
+
+  // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::catalog(this),
+        _Internal::catalog(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string body = 5;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_body().data(), static_cast<int>(this->_internal_body().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.body");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_body(), target);
+  }
+
+  // optional string footer = 6;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_footer().data(), static_cast<int>(this->_internal_footer().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ProductMessage.footer");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_footer(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ProductMessage)
+  return target;
+}
+
+size_t Message_ProductMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional string businessOwnerJid = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_businessownerjid());
+    }
+
+    // optional string body = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_body());
+    }
+
+    // optional string footer = 6;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_footer());
+    }
+
+    // optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.product_);
+    }
+
+    // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.catalog_);
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ProductMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ProductMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ProductMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ProductMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_businessownerjid(from._internal_businessownerjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_body(from._internal_body());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_footer(from._internal_footer());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_product()->::proto::Message_ProductMessage_ProductSnapshot::MergeFrom(
+          from._internal_product());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_catalog()->::proto::Message_ProductMessage_CatalogSnapshot::MergeFrom(
+          from._internal_catalog());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ProductMessage::CopyFrom(const Message_ProductMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ProductMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ProductMessage::InternalSwap(Message_ProductMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.businessownerjid_, lhs_arena,
+      &other->_impl_.businessownerjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.footer_, lhs_arena,
+      &other->_impl_.footer_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.contextinfo_)
+      + sizeof(Message_ProductMessage::_impl_.contextinfo_)
+      - PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.product_)>(
+          reinterpret_cast<char*>(&_impl_.product_),
+          reinterpret_cast<char*>(&other->_impl_.product_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[120]);
+}
+
+// ===================================================================
+
+class Message_ProtocolMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ProtocolMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Message_ProtocolMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_ephemeralexpiration(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::Message_HistorySyncNotification& historysyncnotification(const Message_ProtocolMessage* msg);
+  static void set_has_historysyncnotification(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare(const Message_ProtocolMessage* msg);
+  static void set_has_appstatesynckeyshare(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest(const Message_ProtocolMessage* msg);
+  static void set_has_appstatesynckeyrequest(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg);
+  static void set_has_initialsecuritynotificationsettingsync(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification(const Message_ProtocolMessage* msg);
+  static void set_has_appstatefatalexceptionnotification(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::DisappearingMode& disappearingmode(const Message_ProtocolMessage* msg);
+  static void set_has_disappearingmode(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage(const Message_ProtocolMessage* msg);
+  static void set_has_requestmediauploadmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage(const Message_ProtocolMessage* msg);
+  static void set_has_requestmediauploadresponsemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_ProtocolMessage::_Internal::key(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.key_;
+}
+const ::proto::Message_HistorySyncNotification&
+Message_ProtocolMessage::_Internal::historysyncnotification(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.historysyncnotification_;
+}
+const ::proto::Message_AppStateSyncKeyShare&
+Message_ProtocolMessage::_Internal::appstatesynckeyshare(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.appstatesynckeyshare_;
+}
+const ::proto::Message_AppStateSyncKeyRequest&
+Message_ProtocolMessage::_Internal::appstatesynckeyrequest(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.appstatesynckeyrequest_;
+}
+const ::proto::Message_InitialSecurityNotificationSettingSync&
+Message_ProtocolMessage::_Internal::initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.initialsecuritynotificationsettingsync_;
+}
+const ::proto::Message_AppStateFatalExceptionNotification&
+Message_ProtocolMessage::_Internal::appstatefatalexceptionnotification(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.appstatefatalexceptionnotification_;
+}
+const ::proto::DisappearingMode&
+Message_ProtocolMessage::_Internal::disappearingmode(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.disappearingmode_;
+}
+const ::proto::Message_RequestMediaUploadMessage&
+Message_ProtocolMessage::_Internal::requestmediauploadmessage(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.requestmediauploadmessage_;
+}
+const ::proto::Message_RequestMediaUploadResponseMessage&
+Message_ProtocolMessage::_Internal::requestmediauploadresponsemessage(const Message_ProtocolMessage* msg) {
+  return *msg->_impl_.requestmediauploadresponsemessage_;
+}
+Message_ProtocolMessage::Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ProtocolMessage)
+}
+Message_ProtocolMessage::Message_ProtocolMessage(const Message_ProtocolMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ProtocolMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.historysyncnotification_){nullptr}
+    , decltype(_impl_.appstatesynckeyshare_){nullptr}
+    , decltype(_impl_.appstatesynckeyrequest_){nullptr}
+    , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr}
+    , decltype(_impl_.appstatefatalexceptionnotification_){nullptr}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.requestmediauploadmessage_){nullptr}
+    , decltype(_impl_.requestmediauploadresponsemessage_){nullptr}
+    , decltype(_impl_.type_){}
+    , decltype(_impl_.ephemeralexpiration_){}
+    , decltype(_impl_.ephemeralsettingtimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  if (from._internal_has_historysyncnotification()) {
+    _this->_impl_.historysyncnotification_ = new ::proto::Message_HistorySyncNotification(*from._impl_.historysyncnotification_);
+  }
+  if (from._internal_has_appstatesynckeyshare()) {
+    _this->_impl_.appstatesynckeyshare_ = new ::proto::Message_AppStateSyncKeyShare(*from._impl_.appstatesynckeyshare_);
+  }
+  if (from._internal_has_appstatesynckeyrequest()) {
+    _this->_impl_.appstatesynckeyrequest_ = new ::proto::Message_AppStateSyncKeyRequest(*from._impl_.appstatesynckeyrequest_);
+  }
+  if (from._internal_has_initialsecuritynotificationsettingsync()) {
+    _this->_impl_.initialsecuritynotificationsettingsync_ = new ::proto::Message_InitialSecurityNotificationSettingSync(*from._impl_.initialsecuritynotificationsettingsync_);
+  }
+  if (from._internal_has_appstatefatalexceptionnotification()) {
+    _this->_impl_.appstatefatalexceptionnotification_ = new ::proto::Message_AppStateFatalExceptionNotification(*from._impl_.appstatefatalexceptionnotification_);
+  }
+  if (from._internal_has_disappearingmode()) {
+    _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_);
+  }
+  if (from._internal_has_requestmediauploadmessage()) {
+    _this->_impl_.requestmediauploadmessage_ = new ::proto::Message_RequestMediaUploadMessage(*from._impl_.requestmediauploadmessage_);
+  }
+  if (from._internal_has_requestmediauploadresponsemessage()) {
+    _this->_impl_.requestmediauploadresponsemessage_ = new ::proto::Message_RequestMediaUploadResponseMessage(*from._impl_.requestmediauploadresponsemessage_);
+  }
+  ::memcpy(&_impl_.type_, &from._impl_.type_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ephemeralsettingtimestamp_) -
+    reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ProtocolMessage)
+}
+
+inline void Message_ProtocolMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.historysyncnotification_){nullptr}
+    , decltype(_impl_.appstatesynckeyshare_){nullptr}
+    , decltype(_impl_.appstatesynckeyrequest_){nullptr}
+    , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr}
+    , decltype(_impl_.appstatefatalexceptionnotification_){nullptr}
+    , decltype(_impl_.disappearingmode_){nullptr}
+    , decltype(_impl_.requestmediauploadmessage_){nullptr}
+    , decltype(_impl_.requestmediauploadresponsemessage_){nullptr}
+    , decltype(_impl_.type_){0}
+    , decltype(_impl_.ephemeralexpiration_){0u}
+    , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}}
+  };
+}
+
+Message_ProtocolMessage::~Message_ProtocolMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ProtocolMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ProtocolMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.key_;
+  if (this != internal_default_instance()) delete _impl_.historysyncnotification_;
+  if (this != internal_default_instance()) delete _impl_.appstatesynckeyshare_;
+  if (this != internal_default_instance()) delete _impl_.appstatesynckeyrequest_;
+  if (this != internal_default_instance()) delete _impl_.initialsecuritynotificationsettingsync_;
+  if (this != internal_default_instance()) delete _impl_.appstatefatalexceptionnotification_;
+  if (this != internal_default_instance()) delete _impl_.disappearingmode_;
+  if (this != internal_default_instance()) delete _impl_.requestmediauploadmessage_;
+  if (this != internal_default_instance()) delete _impl_.requestmediauploadresponsemessage_;
+}
+
+void Message_ProtocolMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ProtocolMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ProtocolMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.historysyncnotification_ != nullptr);
+      _impl_.historysyncnotification_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.appstatesynckeyshare_ != nullptr);
+      _impl_.appstatesynckeyshare_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.appstatesynckeyrequest_ != nullptr);
+      _impl_.appstatesynckeyrequest_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.initialsecuritynotificationsettingsync_ != nullptr);
+      _impl_.initialsecuritynotificationsettingsync_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.appstatefatalexceptionnotification_ != nullptr);
+      _impl_.appstatefatalexceptionnotification_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr);
+      _impl_.disappearingmode_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.requestmediauploadmessage_ != nullptr);
+      _impl_.requestmediauploadmessage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000100u) {
+    GOOGLE_DCHECK(_impl_.requestmediauploadresponsemessage_ != nullptr);
+    _impl_.requestmediauploadresponsemessage_->Clear();
+  }
+  if (cached_has_bits & 0x00000e00u) {
+    ::memset(&_impl_.type_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.ephemeralsettingtimestamp_) -
+        reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ProtocolMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ProtocolMessage.Type type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_ProtocolMessage_Type_IsValid(val))) {
+            _internal_set_type(static_cast<::proto::Message_ProtocolMessage_Type>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 ephemeralExpiration = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_ephemeralexpiration(&has_bits);
+          _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 ephemeralSettingTimestamp = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_ephemeralsettingtimestamp(&has_bits);
+          _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_historysyncnotification(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyshare(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyrequest(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_initialsecuritynotificationsettingsync(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_appstatefatalexceptionnotification(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.DisappearingMode disappearingMode = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadresponsemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ProtocolMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProtocolMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ProtocolMessage.Type type = 2;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_type(), target);
+  }
+
+  // optional uint32 ephemeralExpiration = 4;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ephemeralexpiration(), target);
+  }
+
+  // optional int64 ephemeralSettingTimestamp = 5;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_ephemeralsettingtimestamp(), target);
+  }
+
+  // optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::historysyncnotification(this),
+        _Internal::historysyncnotification(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::appstatesynckeyshare(this),
+        _Internal::appstatesynckeyshare(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::appstatesynckeyrequest(this),
+        _Internal::appstatesynckeyrequest(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::initialsecuritynotificationsettingsync(this),
+        _Internal::initialsecuritynotificationsettingsync(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(10, _Internal::appstatefatalexceptionnotification(this),
+        _Internal::appstatefatalexceptionnotification(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.DisappearingMode disappearingMode = 11;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(11, _Internal::disappearingmode(this),
+        _Internal::disappearingmode(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(12, _Internal::requestmediauploadmessage(this),
+        _Internal::requestmediauploadmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(13, _Internal::requestmediauploadresponsemessage(this),
+        _Internal::requestmediauploadresponsemessage(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ProtocolMessage)
+  return target;
+}
+
+size_t Message_ProtocolMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProtocolMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.historysyncnotification_);
+    }
+
+    // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.appstatesynckeyshare_);
+    }
+
+    // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.appstatesynckeyrequest_);
+    }
+
+    // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.initialsecuritynotificationsettingsync_);
+    }
+
+    // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.appstatefatalexceptionnotification_);
+    }
+
+    // optional .proto.DisappearingMode disappearingMode = 11;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.disappearingmode_);
+    }
+
+    // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestmediauploadmessage_);
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestmediauploadresponsemessage_);
+    }
+
+    // optional .proto.Message.ProtocolMessage.Type type = 2;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+    // optional uint32 ephemeralExpiration = 4;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration());
+    }
+
+    // optional int64 ephemeralSettingTimestamp = 5;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProtocolMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ProtocolMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProtocolMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ProtocolMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ProtocolMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ProtocolMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProtocolMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_historysyncnotification()->::proto::Message_HistorySyncNotification::MergeFrom(
+          from._internal_historysyncnotification());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_appstatesynckeyshare()->::proto::Message_AppStateSyncKeyShare::MergeFrom(
+          from._internal_appstatesynckeyshare());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_appstatesynckeyrequest()->::proto::Message_AppStateSyncKeyRequest::MergeFrom(
+          from._internal_appstatesynckeyrequest());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_initialsecuritynotificationsettingsync()->::proto::Message_InitialSecurityNotificationSettingSync::MergeFrom(
+          from._internal_initialsecuritynotificationsettingsync());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_appstatefatalexceptionnotification()->::proto::Message_AppStateFatalExceptionNotification::MergeFrom(
+          from._internal_appstatefatalexceptionnotification());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom(
+          from._internal_disappearingmode());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_requestmediauploadmessage()->::proto::Message_RequestMediaUploadMessage::MergeFrom(
+          from._internal_requestmediauploadmessage());
+    }
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_requestmediauploadresponsemessage()->::proto::Message_RequestMediaUploadResponseMessage::MergeFrom(
+          from._internal_requestmediauploadresponsemessage());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ProtocolMessage::CopyFrom(const Message_ProtocolMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProtocolMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ProtocolMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ProtocolMessage::InternalSwap(Message_ProtocolMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_)
+      + sizeof(Message_ProtocolMessage::_impl_.ephemeralsettingtimestamp_)
+      - PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ProtocolMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[121]);
+}
+
+// ===================================================================
+
+class Message_ReactionMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_ReactionMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Message_ReactionMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_groupingkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_sendertimestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::MessageKey&
+Message_ReactionMessage::_Internal::key(const Message_ReactionMessage* msg) {
+  return *msg->_impl_.key_;
+}
+Message_ReactionMessage::Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.ReactionMessage)
+}
+Message_ReactionMessage::Message_ReactionMessage(const Message_ReactionMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_ReactionMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.groupingkey_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.sendertimestampms_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.groupingkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupingkey()) {
+    _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.ReactionMessage)
+}
+
+inline void Message_ReactionMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.groupingkey_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.sendertimestampms_){int64_t{0}}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.groupingkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_ReactionMessage::~Message_ReactionMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.ReactionMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_ReactionMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+  _impl_.groupingkey_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void Message_ReactionMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_ReactionMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.ReactionMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.text_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.groupingkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+  }
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_ReactionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string text = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string groupingKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_groupingkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.groupingKey");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 senderTimestampMs = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_sendertimestampms(&has_bits);
+          _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_ReactionMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ReactionMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string text = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ReactionMessage.text");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_text(), target);
+  }
+
+  // optional string groupingKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupingkey().data(), static_cast<int>(this->_internal_groupingkey().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.ReactionMessage.groupingKey");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_groupingkey(), target);
+  }
+
+  // optional int64 senderTimestampMs = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.ReactionMessage)
+  return target;
+}
+
+size_t Message_ReactionMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.ReactionMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string text = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_text());
+    }
+
+    // optional string groupingKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupingkey());
+    }
+
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional int64 senderTimestampMs = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ReactionMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_ReactionMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ReactionMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_ReactionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_ReactionMessage*>(&to_msg);
+  auto& from = static_cast<const Message_ReactionMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ReactionMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_text(from._internal_text());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_groupingkey(from._internal_groupingkey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_ReactionMessage::CopyFrom(const Message_ReactionMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ReactionMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_ReactionMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_ReactionMessage::InternalSwap(Message_ReactionMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupingkey_, lhs_arena,
+      &other->_impl_.groupingkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.sendertimestampms_)
+      + sizeof(Message_ReactionMessage::_impl_.sendertimestampms_)
+      - PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_ReactionMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[122]);
+}
+
+// ===================================================================
+
+class Message_RequestMediaUploadMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_RequestMediaUploadMessage>()._impl_._has_bits_);
+  static void set_has_rmrsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadMessage)
+}
+Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_RequestMediaUploadMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){from._impl_.filesha256_}
+    , decltype(_impl_.rmrsource_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.rmrsource_ = from._impl_.rmrsource_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadMessage)
+}
+
+inline void Message_RequestMediaUploadMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){arena}
+    , decltype(_impl_.rmrsource_){0}
+  };
+}
+
+Message_RequestMediaUploadMessage::~Message_RequestMediaUploadMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_RequestMediaUploadMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.filesha256_.~RepeatedPtrField();
+}
+
+void Message_RequestMediaUploadMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_RequestMediaUploadMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.filesha256_.Clear();
+  _impl_.rmrsource_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_RequestMediaUploadMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string fileSha256 = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_filesha256();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadMessage.fileSha256");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.RmrSource rmrSource = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) {
+            _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_RequestMediaUploadMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string fileSha256 = 1;
+  for (int i = 0, n = this->_internal_filesha256_size(); i < n; i++) {
+    const auto& s = this->_internal_filesha256(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.RequestMediaUploadMessage.fileSha256");
+    target = stream->WriteString(1, s, target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.RmrSource rmrSource = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_rmrsource(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.RequestMediaUploadMessage)
+  return target;
+}
+
+size_t Message_RequestMediaUploadMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string fileSha256 = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filesha256_.size());
+  for (int i = 0, n = _impl_.filesha256_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.filesha256_.Get(i));
+  }
+
+  // optional .proto.Message.RmrSource rmrSource = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_RequestMediaUploadMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_RequestMediaUploadMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_RequestMediaUploadMessage*>(&to_msg);
+  auto& from = static_cast<const Message_RequestMediaUploadMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.filesha256_.MergeFrom(from._impl_.filesha256_);
+  if (from._internal_has_rmrsource()) {
+    _this->_internal_set_rmrsource(from._internal_rmrsource());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_RequestMediaUploadMessage::CopyFrom(const Message_RequestMediaUploadMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_RequestMediaUploadMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_RequestMediaUploadMessage::InternalSwap(Message_RequestMediaUploadMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.filesha256_.InternalSwap(&other->_impl_.filesha256_);
+  swap(_impl_.rmrsource_, other->_impl_.rmrsource_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[123]);
+}
+
+// ===================================================================
+
+class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>()._impl_._has_bits_);
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mediauploadresult(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::Message_StickerMessage& stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg);
+  static void set_has_stickermessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_StickerMessage&
+Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal::stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg) {
+  return *msg->_impl_.stickermessage_;
+}
+Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+}
+Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.stickermessage_){nullptr}
+    , decltype(_impl_.mediauploadresult_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_stickermessage()) {
+    _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_);
+  }
+  _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+}
+
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.stickermessage_){nullptr}
+    , decltype(_impl_.mediauploadresult_){0}
+  };
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() {
+  // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.filesha256_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.stickermessage_;
+}
+
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr);
+      _impl_.stickermessage_->Clear();
+    }
+  }
+  _impl_.mediauploadresult_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string fileSha256 = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) {
+            _internal_set_mediauploadresult(static_cast<::proto::MediaRetryNotification_ResultType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.StickerMessage stickerMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string fileSha256 = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_filesha256().data(), static_cast<int>(this->_internal_filesha256().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_filesha256(), target);
+  }
+
+  // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_mediauploadresult(), target);
+  }
+
+  // optional .proto.Message.StickerMessage stickerMessage = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::stickermessage(this),
+        _Internal::stickermessage(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  return target;
+}
+
+size_t Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string fileSha256 = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_filesha256());
+    }
+
+    // optional .proto.Message.StickerMessage stickerMessage = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.stickermessage_);
+    }
+
+    // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadresult());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetClassData() const { return &_class_data_; }
+
+
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult*>(&to_msg);
+  auto& from = static_cast<const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom(
+          from._internal_stickermessage());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::IsInitialized() const {
+  return true;
+}
+
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_)
+      + sizeof(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_impl_.mediauploadresult_)
+      - PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_)>(
+          reinterpret_cast<char*>(&_impl_.stickermessage_),
+          reinterpret_cast<char*>(&other->_impl_.stickermessage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[124]);
+}
+
+// ===================================================================
+
+class Message_RequestMediaUploadResponseMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_RequestMediaUploadResponseMessage>()._impl_._has_bits_);
+  static void set_has_rmrsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_stanzaid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage)
+}
+Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_RequestMediaUploadResponseMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.reuploadresult_){from._impl_.reuploadresult_}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.rmrsource_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_stanzaid()) {
+    _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.rmrsource_ = from._impl_.rmrsource_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage)
+}
+
+inline void Message_RequestMediaUploadResponseMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.reuploadresult_){arena}
+    , decltype(_impl_.stanzaid_){}
+    , decltype(_impl_.rmrsource_){0}
+  };
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_RequestMediaUploadResponseMessage::~Message_RequestMediaUploadResponseMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_RequestMediaUploadResponseMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.reuploadresult_.~RepeatedPtrField();
+  _impl_.stanzaid_.Destroy();
+}
+
+void Message_RequestMediaUploadResponseMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_RequestMediaUploadResponseMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.reuploadresult_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.stanzaid_.ClearNonDefaultToEmpty();
+  }
+  _impl_.rmrsource_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_RequestMediaUploadResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.RmrSource rmrSource = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) {
+            _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string stanzaId = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_stanzaid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.stanzaId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_reuploadresult(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_RequestMediaUploadResponseMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.RmrSource rmrSource = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_rmrsource(), target);
+  }
+
+  // optional string stanzaId = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_stanzaid().data(), static_cast<int>(this->_internal_stanzaid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.RequestMediaUploadResponseMessage.stanzaId");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_stanzaid(), target);
+  }
+
+  // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_reuploadresult_size()); i < n; i++) {
+    const auto& repfield = this->_internal_reuploadresult(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.RequestMediaUploadResponseMessage)
+  return target;
+}
+
+size_t Message_RequestMediaUploadResponseMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
+  total_size += 1UL * this->_internal_reuploadresult_size();
+  for (const auto& msg : this->_impl_.reuploadresult_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string stanzaId = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_stanzaid());
+    }
+
+    // optional .proto.Message.RmrSource rmrSource = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_RequestMediaUploadResponseMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_RequestMediaUploadResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_RequestMediaUploadResponseMessage*>(&to_msg);
+  auto& from = static_cast<const Message_RequestMediaUploadResponseMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.reuploadresult_.MergeFrom(from._impl_.reuploadresult_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_stanzaid(from._internal_stanzaid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.rmrsource_ = from._impl_.rmrsource_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_RequestMediaUploadResponseMessage::CopyFrom(const Message_RequestMediaUploadResponseMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_RequestMediaUploadResponseMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_RequestMediaUploadResponseMessage::InternalSwap(Message_RequestMediaUploadResponseMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.reuploadresult_.InternalSwap(&other->_impl_.reuploadresult_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.stanzaid_, lhs_arena,
+      &other->_impl_.stanzaid_, rhs_arena
+  );
+  swap(_impl_.rmrsource_, other->_impl_.rmrsource_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[125]);
+}
+
+// ===================================================================
+
+class Message_RequestPaymentMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_RequestPaymentMessage>()._impl_._has_bits_);
+  static const ::proto::Message& notemessage(const Message_RequestPaymentMessage* msg);
+  static void set_has_notemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_currencycodeiso4217(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_amount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_requestfrom(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_expirytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::Money& amount(const Message_RequestPaymentMessage* msg);
+  static void set_has_amount(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::PaymentBackground& background(const Message_RequestPaymentMessage* msg);
+  static void set_has_background(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+const ::proto::Message&
+Message_RequestPaymentMessage::_Internal::notemessage(const Message_RequestPaymentMessage* msg) {
+  return *msg->_impl_.notemessage_;
+}
+const ::proto::Money&
+Message_RequestPaymentMessage::_Internal::amount(const Message_RequestPaymentMessage* msg) {
+  return *msg->_impl_.amount_;
+}
+const ::proto::PaymentBackground&
+Message_RequestPaymentMessage::_Internal::background(const Message_RequestPaymentMessage* msg) {
+  return *msg->_impl_.background_;
+}
+Message_RequestPaymentMessage::Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPaymentMessage)
+}
+Message_RequestPaymentMessage::Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_RequestPaymentMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycodeiso4217_){}
+    , decltype(_impl_.requestfrom_){}
+    , decltype(_impl_.notemessage_){nullptr}
+    , decltype(_impl_.amount_){nullptr}
+    , decltype(_impl_.background_){nullptr}
+    , decltype(_impl_.amount1000_){}
+    , decltype(_impl_.expirytimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.currencycodeiso4217_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_currencycodeiso4217()) {
+    _this->_impl_.currencycodeiso4217_.Set(from._internal_currencycodeiso4217(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.requestfrom_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.requestfrom_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_requestfrom()) {
+    _this->_impl_.requestfrom_.Set(from._internal_requestfrom(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_notemessage()) {
+    _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_);
+  }
+  if (from._internal_has_amount()) {
+    _this->_impl_.amount_ = new ::proto::Money(*from._impl_.amount_);
+  }
+  if (from._internal_has_background()) {
+    _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_);
+  }
+  ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.expirytimestamp_) -
+    reinterpret_cast<char*>(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPaymentMessage)
+}
+
+inline void Message_RequestPaymentMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycodeiso4217_){}
+    , decltype(_impl_.requestfrom_){}
+    , decltype(_impl_.notemessage_){nullptr}
+    , decltype(_impl_.amount_){nullptr}
+    , decltype(_impl_.background_){nullptr}
+    , decltype(_impl_.amount1000_){uint64_t{0u}}
+    , decltype(_impl_.expirytimestamp_){int64_t{0}}
+  };
+  _impl_.currencycodeiso4217_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.requestfrom_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.requestfrom_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_RequestPaymentMessage::~Message_RequestPaymentMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.RequestPaymentMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_RequestPaymentMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.currencycodeiso4217_.Destroy();
+  _impl_.requestfrom_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.notemessage_;
+  if (this != internal_default_instance()) delete _impl_.amount_;
+  if (this != internal_default_instance()) delete _impl_.background_;
+}
+
+void Message_RequestPaymentMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_RequestPaymentMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPaymentMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.currencycodeiso4217_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.requestfrom_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.notemessage_ != nullptr);
+      _impl_.notemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.amount_ != nullptr);
+      _impl_.amount_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.background_ != nullptr);
+      _impl_.background_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000060u) {
+    ::memset(&_impl_.amount1000_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.expirytimestamp_) -
+        reinterpret_cast<char*>(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_RequestPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string currencyCodeIso4217 = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_currencycodeiso4217();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.currencyCodeIso4217");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 amount1000 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_amount1000(&has_bits);
+          _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string requestFrom = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_requestfrom();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.requestFrom");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message noteMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 expiryTimestamp = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_expirytimestamp(&has_bits);
+          _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Money amount = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_amount(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentBackground background = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_background(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_RequestPaymentMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPaymentMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string currencyCodeIso4217 = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_currencycodeiso4217().data(), static_cast<int>(this->_internal_currencycodeiso4217().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.RequestPaymentMessage.currencyCodeIso4217");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_currencycodeiso4217(), target);
+  }
+
+  // optional uint64 amount1000 = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target);
+  }
+
+  // optional string requestFrom = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_requestfrom().data(), static_cast<int>(this->_internal_requestfrom().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.RequestPaymentMessage.requestFrom");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_requestfrom(), target);
+  }
+
+  // optional .proto.Message noteMessage = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::notemessage(this),
+        _Internal::notemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 expiryTimestamp = 5;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_expirytimestamp(), target);
+  }
+
+  // optional .proto.Money amount = 6;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::amount(this),
+        _Internal::amount(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PaymentBackground background = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::background(this),
+        _Internal::background(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.RequestPaymentMessage)
+  return target;
+}
+
+size_t Message_RequestPaymentMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPaymentMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional string currencyCodeIso4217 = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_currencycodeiso4217());
+    }
+
+    // optional string requestFrom = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_requestfrom());
+    }
+
+    // optional .proto.Message noteMessage = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.notemessage_);
+    }
+
+    // optional .proto.Money amount = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.amount_);
+    }
+
+    // optional .proto.PaymentBackground background = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.background_);
+    }
+
+    // optional uint64 amount1000 = 2;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000());
+    }
+
+    // optional int64 expiryTimestamp = 5;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPaymentMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_RequestPaymentMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPaymentMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_RequestPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_RequestPaymentMessage*>(&to_msg);
+  auto& from = static_cast<const Message_RequestPaymentMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPaymentMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_currencycodeiso4217(from._internal_currencycodeiso4217());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_requestfrom(from._internal_requestfrom());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom(
+          from._internal_notemessage());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_amount()->::proto::Money::MergeFrom(
+          from._internal_amount());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom(
+          from._internal_background());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.amount1000_ = from._impl_.amount1000_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_RequestPaymentMessage::CopyFrom(const Message_RequestPaymentMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPaymentMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_RequestPaymentMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_RequestPaymentMessage::InternalSwap(Message_RequestPaymentMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.currencycodeiso4217_, lhs_arena,
+      &other->_impl_.currencycodeiso4217_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.requestfrom_, lhs_arena,
+      &other->_impl_.requestfrom_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.expirytimestamp_)
+      + sizeof(Message_RequestPaymentMessage::_impl_.expirytimestamp_)
+      - PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.notemessage_)>(
+          reinterpret_cast<char*>(&_impl_.notemessage_),
+          reinterpret_cast<char*>(&other->_impl_.notemessage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPaymentMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[126]);
+}
+
+// ===================================================================
+
+class Message_RequestPhoneNumberMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_RequestPhoneNumberMessage>()._impl_._has_bits_);
+  static const ::proto::ContextInfo& contextinfo(const Message_RequestPhoneNumberMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_RequestPhoneNumberMessage::_Internal::contextinfo(const Message_RequestPhoneNumberMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPhoneNumberMessage)
+}
+Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_RequestPhoneNumberMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contextinfo_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPhoneNumberMessage)
+}
+
+inline void Message_RequestPhoneNumberMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contextinfo_){nullptr}
+  };
+}
+
+Message_RequestPhoneNumberMessage::~Message_RequestPhoneNumberMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.RequestPhoneNumberMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_RequestPhoneNumberMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_RequestPhoneNumberMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_RequestPhoneNumberMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPhoneNumberMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+    _impl_.contextinfo_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_RequestPhoneNumberMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.ContextInfo contextInfo = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_RequestPhoneNumberMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPhoneNumberMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.ContextInfo contextInfo = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.RequestPhoneNumberMessage)
+  return target;
+}
+
+size_t Message_RequestPhoneNumberMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPhoneNumberMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.ContextInfo contextInfo = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.contextinfo_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPhoneNumberMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_RequestPhoneNumberMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPhoneNumberMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_RequestPhoneNumberMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_RequestPhoneNumberMessage*>(&to_msg);
+  auto& from = static_cast<const Message_RequestPhoneNumberMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPhoneNumberMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_contextinfo()) {
+    _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+        from._internal_contextinfo());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_RequestPhoneNumberMessage::CopyFrom(const Message_RequestPhoneNumberMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPhoneNumberMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_RequestPhoneNumberMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_RequestPhoneNumberMessage::InternalSwap(Message_RequestPhoneNumberMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.contextinfo_, other->_impl_.contextinfo_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPhoneNumberMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[127]);
+}
+
+// ===================================================================
+
+class Message_SendPaymentMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_SendPaymentMessage>()._impl_._has_bits_);
+  static const ::proto::Message& notemessage(const Message_SendPaymentMessage* msg);
+  static void set_has_notemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::MessageKey& requestmessagekey(const Message_SendPaymentMessage* msg);
+  static void set_has_requestmessagekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::PaymentBackground& background(const Message_SendPaymentMessage* msg);
+  static void set_has_background(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::Message&
+Message_SendPaymentMessage::_Internal::notemessage(const Message_SendPaymentMessage* msg) {
+  return *msg->_impl_.notemessage_;
+}
+const ::proto::MessageKey&
+Message_SendPaymentMessage::_Internal::requestmessagekey(const Message_SendPaymentMessage* msg) {
+  return *msg->_impl_.requestmessagekey_;
+}
+const ::proto::PaymentBackground&
+Message_SendPaymentMessage::_Internal::background(const Message_SendPaymentMessage* msg) {
+  return *msg->_impl_.background_;
+}
+Message_SendPaymentMessage::Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.SendPaymentMessage)
+}
+Message_SendPaymentMessage::Message_SendPaymentMessage(const Message_SendPaymentMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_SendPaymentMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notemessage_){nullptr}
+    , decltype(_impl_.requestmessagekey_){nullptr}
+    , decltype(_impl_.background_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_notemessage()) {
+    _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_);
+  }
+  if (from._internal_has_requestmessagekey()) {
+    _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_);
+  }
+  if (from._internal_has_background()) {
+    _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.SendPaymentMessage)
+}
+
+inline void Message_SendPaymentMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notemessage_){nullptr}
+    , decltype(_impl_.requestmessagekey_){nullptr}
+    , decltype(_impl_.background_){nullptr}
+  };
+}
+
+Message_SendPaymentMessage::~Message_SendPaymentMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.SendPaymentMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_SendPaymentMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.notemessage_;
+  if (this != internal_default_instance()) delete _impl_.requestmessagekey_;
+  if (this != internal_default_instance()) delete _impl_.background_;
+}
+
+void Message_SendPaymentMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_SendPaymentMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.SendPaymentMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.notemessage_ != nullptr);
+      _impl_.notemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr);
+      _impl_.requestmessagekey_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.background_ != nullptr);
+      _impl_.background_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_SendPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message noteMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MessageKey requestMessageKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentBackground background = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_background(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_SendPaymentMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SendPaymentMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message noteMessage = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::notemessage(this),
+        _Internal::notemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MessageKey requestMessageKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::requestmessagekey(this),
+        _Internal::requestmessagekey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PaymentBackground background = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::background(this),
+        _Internal::background(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.SendPaymentMessage)
+  return target;
+}
+
+size_t Message_SendPaymentMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.SendPaymentMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.Message noteMessage = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.notemessage_);
+    }
+
+    // optional .proto.MessageKey requestMessageKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestmessagekey_);
+    }
+
+    // optional .proto.PaymentBackground background = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.background_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SendPaymentMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_SendPaymentMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SendPaymentMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_SendPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_SendPaymentMessage*>(&to_msg);
+  auto& from = static_cast<const Message_SendPaymentMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SendPaymentMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom(
+          from._internal_notemessage());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom(
+          from._internal_requestmessagekey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom(
+          from._internal_background());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_SendPaymentMessage::CopyFrom(const Message_SendPaymentMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SendPaymentMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_SendPaymentMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_SendPaymentMessage::InternalSwap(Message_SendPaymentMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.background_)
+      + sizeof(Message_SendPaymentMessage::_impl_.background_)
+      - PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.notemessage_)>(
+          reinterpret_cast<char*>(&_impl_.notemessage_),
+          reinterpret_cast<char*>(&other->_impl_.notemessage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_SendPaymentMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[128]);
+}
+
+// ===================================================================
+
+class Message_SenderKeyDistributionMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_SenderKeyDistributionMessage>()._impl_._has_bits_);
+  static void set_has_groupid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_axolotlsenderkeydistributionmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.SenderKeyDistributionMessage)
+}
+Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_SenderKeyDistributionMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.groupid_){}
+    , decltype(_impl_.axolotlsenderkeydistributionmessage_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.groupid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupid()) {
+    _this->_impl_.groupid_.Set(from._internal_groupid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.axolotlsenderkeydistributionmessage_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_axolotlsenderkeydistributionmessage()) {
+    _this->_impl_.axolotlsenderkeydistributionmessage_.Set(from._internal_axolotlsenderkeydistributionmessage(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.SenderKeyDistributionMessage)
+}
+
+inline void Message_SenderKeyDistributionMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.groupid_){}
+    , decltype(_impl_.axolotlsenderkeydistributionmessage_){}
+  };
+  _impl_.groupid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.axolotlsenderkeydistributionmessage_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_SenderKeyDistributionMessage::~Message_SenderKeyDistributionMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.SenderKeyDistributionMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_SenderKeyDistributionMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.groupid_.Destroy();
+  _impl_.axolotlsenderkeydistributionmessage_.Destroy();
+}
+
+void Message_SenderKeyDistributionMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_SenderKeyDistributionMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.SenderKeyDistributionMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.groupid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.axolotlsenderkeydistributionmessage_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_SenderKeyDistributionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string groupId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_groupid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.SenderKeyDistributionMessage.groupId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes axolotlSenderKeyDistributionMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_axolotlsenderkeydistributionmessage();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_SenderKeyDistributionMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SenderKeyDistributionMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string groupId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupid().data(), static_cast<int>(this->_internal_groupid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.SenderKeyDistributionMessage.groupId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_groupid(), target);
+  }
+
+  // optional bytes axolotlSenderKeyDistributionMessage = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_axolotlsenderkeydistributionmessage(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.SenderKeyDistributionMessage)
+  return target;
+}
+
+size_t Message_SenderKeyDistributionMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.SenderKeyDistributionMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string groupId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupid());
+    }
+
+    // optional bytes axolotlSenderKeyDistributionMessage = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_axolotlsenderkeydistributionmessage());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SenderKeyDistributionMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_SenderKeyDistributionMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SenderKeyDistributionMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_SenderKeyDistributionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_SenderKeyDistributionMessage*>(&to_msg);
+  auto& from = static_cast<const Message_SenderKeyDistributionMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SenderKeyDistributionMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_groupid(from._internal_groupid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_axolotlsenderkeydistributionmessage(from._internal_axolotlsenderkeydistributionmessage());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_SenderKeyDistributionMessage::CopyFrom(const Message_SenderKeyDistributionMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SenderKeyDistributionMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_SenderKeyDistributionMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_SenderKeyDistributionMessage::InternalSwap(Message_SenderKeyDistributionMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupid_, lhs_arena,
+      &other->_impl_.groupid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.axolotlsenderkeydistributionmessage_, lhs_arena,
+      &other->_impl_.axolotlsenderkeydistributionmessage_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_SenderKeyDistributionMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[129]);
+}
+
+// ===================================================================
+
+class Message_StickerMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_StickerMessage>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_firstframelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_firstframesidecar(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_isanimated(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_pngthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_StickerMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_StickerMessage::_Internal::contextinfo(const Message_StickerMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_StickerMessage::Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.StickerMessage)
+}
+Message_StickerMessage::Message_StickerMessage(const Message_StickerMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_StickerMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.firstframesidecar_){}
+    , decltype(_impl_.pngthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.mediakeytimestamp_){}
+    , decltype(_impl_.firstframelength_){}
+    , decltype(_impl_.isanimated_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.firstframesidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_firstframesidecar()) {
+    _this->_impl_.firstframesidecar_.Set(from._internal_firstframesidecar(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pngthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pngthumbnail()) {
+    _this->_impl_.pngthumbnail_.Set(from._internal_pngthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.height_, &from._impl_.height_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.isanimated_) -
+    reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.isanimated_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.StickerMessage)
+}
+
+inline void Message_StickerMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.firstframesidecar_){}
+    , decltype(_impl_.pngthumbnail_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.firstframelength_){0u}
+    , decltype(_impl_.isanimated_){false}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.firstframesidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pngthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_StickerMessage::~Message_StickerMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.StickerMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_StickerMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.firstframesidecar_.Destroy();
+  _impl_.pngthumbnail_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_StickerMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_StickerMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.StickerMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.firstframesidecar_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.pngthumbnail_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000100u) {
+    GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+    _impl_.contextinfo_->Clear();
+  }
+  if (cached_has_bits & 0x00007e00u) {
+    ::memset(&_impl_.height_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.isanimated_) -
+        reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.isanimated_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_StickerMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 firstFrameLength = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_firstframelength(&has_bits);
+          _impl_.firstframelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes firstFrameSidecar = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          auto str = _internal_mutable_firstframesidecar();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isAnimated = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          _Internal::set_has_isanimated(&has_bits);
+          _impl_.isanimated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes pngThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_pngthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_StickerMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.StickerMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional bytes fileSha256 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_filesha256(), target);
+  }
+
+  // optional bytes fileEncSha256 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_fileencsha256(), target);
+  }
+
+  // optional bytes mediaKey = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_mediakey(), target);
+  }
+
+  // optional string mimetype = 5;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.StickerMessage.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_mimetype(), target);
+  }
+
+  // optional uint32 height = 6;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target);
+  }
+
+  // optional uint32 width = 7;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target);
+  }
+
+  // optional string directPath = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.StickerMessage.directPath");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_directpath(), target);
+  }
+
+  // optional uint64 fileLength = 9;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 10;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional uint32 firstFrameLength = 11;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_firstframelength(), target);
+  }
+
+  // optional bytes firstFrameSidecar = 12;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        12, this->_internal_firstframesidecar(), target);
+  }
+
+  // optional bool isAnimated = 13;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(13, this->_internal_isanimated(), target);
+  }
+
+  // optional bytes pngThumbnail = 16;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_pngthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.StickerMessage)
+  return target;
+}
+
+size_t Message_StickerMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional bytes fileSha256 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes fileEncSha256 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional bytes mediaKey = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string mimetype = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional string directPath = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional bytes firstFrameSidecar = 12;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_firstframesidecar());
+    }
+
+    // optional bytes pngThumbnail = 16;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pngthumbnail());
+    }
+
+  }
+  if (cached_has_bits & 0x00007f00u) {
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint32 height = 6;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional uint32 width = 7;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+    // optional uint64 fileLength = 9;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional int64 mediaKeyTimestamp = 10;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+    // optional uint32 firstFrameLength = 11;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_firstframelength());
+    }
+
+    // optional bool isAnimated = 13;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_StickerMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_StickerMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_StickerMessage*>(&to_msg);
+  auto& from = static_cast<const Message_StickerMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_firstframesidecar(from._internal_firstframesidecar());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_pngthumbnail(from._internal_pngthumbnail());
+    }
+  }
+  if (cached_has_bits & 0x00007f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.firstframelength_ = from._impl_.firstframelength_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.isanimated_ = from._impl_.isanimated_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_StickerMessage::CopyFrom(const Message_StickerMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_StickerMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_StickerMessage::InternalSwap(Message_StickerMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.firstframesidecar_, lhs_arena,
+      &other->_impl_.firstframesidecar_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pngthumbnail_, lhs_arena,
+      &other->_impl_.pngthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.isanimated_)
+      + sizeof(Message_StickerMessage::_impl_.isanimated_)
+      - PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[130]);
+}
+
+// ===================================================================
+
+class Message_StickerSyncRMRMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_StickerSyncRMRMessage>()._impl_._has_bits_);
+  static void set_has_rmrsource(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_requesttimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.StickerSyncRMRMessage)
+}
+Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_StickerSyncRMRMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filehash_){from._impl_.filehash_}
+    , decltype(_impl_.rmrsource_){}
+    , decltype(_impl_.requesttimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.rmrsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rmrsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_rmrsource()) {
+    _this->_impl_.rmrsource_.Set(from._internal_rmrsource(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.StickerSyncRMRMessage)
+}
+
+inline void Message_StickerSyncRMRMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filehash_){arena}
+    , decltype(_impl_.rmrsource_){}
+    , decltype(_impl_.requesttimestamp_){int64_t{0}}
+  };
+  _impl_.rmrsource_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rmrsource_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_StickerSyncRMRMessage::~Message_StickerSyncRMRMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.StickerSyncRMRMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_StickerSyncRMRMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.filehash_.~RepeatedPtrField();
+  _impl_.rmrsource_.Destroy();
+}
+
+void Message_StickerSyncRMRMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_StickerSyncRMRMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.StickerSyncRMRMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.filehash_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.rmrsource_.ClearNonDefaultToEmpty();
+  }
+  _impl_.requesttimestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_StickerSyncRMRMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string filehash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_filehash();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.filehash");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string rmrSource = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_rmrsource();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.rmrSource");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 requestTimestamp = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_requesttimestamp(&has_bits);
+          _impl_.requesttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_StickerSyncRMRMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerSyncRMRMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string filehash = 1;
+  for (int i = 0, n = this->_internal_filehash_size(); i < n; i++) {
+    const auto& s = this->_internal_filehash(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.StickerSyncRMRMessage.filehash");
+    target = stream->WriteString(1, s, target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string rmrSource = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_rmrsource().data(), static_cast<int>(this->_internal_rmrsource().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.StickerSyncRMRMessage.rmrSource");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_rmrsource(), target);
+  }
+
+  // optional int64 requestTimestamp = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_requesttimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.StickerSyncRMRMessage)
+  return target;
+}
+
+size_t Message_StickerSyncRMRMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerSyncRMRMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string filehash = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filehash_.size());
+  for (int i = 0, n = _impl_.filehash_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.filehash_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string rmrSource = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_rmrsource());
+    }
+
+    // optional int64 requestTimestamp = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_requesttimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerSyncRMRMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_StickerSyncRMRMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerSyncRMRMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_StickerSyncRMRMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_StickerSyncRMRMessage*>(&to_msg);
+  auto& from = static_cast<const Message_StickerSyncRMRMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerSyncRMRMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.filehash_.MergeFrom(from._impl_.filehash_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_rmrsource(from._internal_rmrsource());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_StickerSyncRMRMessage::CopyFrom(const Message_StickerSyncRMRMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerSyncRMRMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_StickerSyncRMRMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_StickerSyncRMRMessage::InternalSwap(Message_StickerSyncRMRMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.filehash_.InternalSwap(&other->_impl_.filehash_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.rmrsource_, lhs_arena,
+      &other->_impl_.rmrsource_, rhs_arena
+  );
+  swap(_impl_.requesttimestamp_, other->_impl_.requesttimestamp_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerSyncRMRMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[131]);
+}
+
+// ===================================================================
+
+class Message_TemplateButtonReplyMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_TemplateButtonReplyMessage>()._impl_._has_bits_);
+  static void set_has_selectedid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_selecteddisplaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_TemplateButtonReplyMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_selectedindex(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_TemplateButtonReplyMessage::_Internal::contextinfo(const Message_TemplateButtonReplyMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateButtonReplyMessage)
+}
+Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_TemplateButtonReplyMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedid_){}
+    , decltype(_impl_.selecteddisplaytext_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.selectedindex_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.selectedid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_selectedid()) {
+    _this->_impl_.selectedid_.Set(from._internal_selectedid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.selecteddisplaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_selecteddisplaytext()) {
+    _this->_impl_.selecteddisplaytext_.Set(from._internal_selecteddisplaytext(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  _this->_impl_.selectedindex_ = from._impl_.selectedindex_;
+  // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateButtonReplyMessage)
+}
+
+inline void Message_TemplateButtonReplyMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.selectedid_){}
+    , decltype(_impl_.selecteddisplaytext_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.selectedindex_){0u}
+  };
+  _impl_.selectedid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selectedid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.selecteddisplaytext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_TemplateButtonReplyMessage::~Message_TemplateButtonReplyMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.TemplateButtonReplyMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_TemplateButtonReplyMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.selectedid_.Destroy();
+  _impl_.selecteddisplaytext_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_TemplateButtonReplyMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_TemplateButtonReplyMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateButtonReplyMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.selectedid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.selecteddisplaytext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  _impl_.selectedindex_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_TemplateButtonReplyMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string selectedId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_selectedid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string selectedDisplayText = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_selecteddisplaytext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedDisplayText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 selectedIndex = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_selectedindex(&has_bits);
+          _impl_.selectedindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_TemplateButtonReplyMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateButtonReplyMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string selectedId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_selectedid().data(), static_cast<int>(this->_internal_selectedid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.TemplateButtonReplyMessage.selectedId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_selectedid(), target);
+  }
+
+  // optional string selectedDisplayText = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_selecteddisplaytext().data(), static_cast<int>(this->_internal_selecteddisplaytext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.TemplateButtonReplyMessage.selectedDisplayText");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_selecteddisplaytext(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 selectedIndex = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectedindex(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.TemplateButtonReplyMessage)
+  return target;
+}
+
+size_t Message_TemplateButtonReplyMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateButtonReplyMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string selectedId = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_selectedid());
+    }
+
+    // optional string selectedDisplayText = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_selecteddisplaytext());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint32 selectedIndex = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectedindex());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateButtonReplyMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_TemplateButtonReplyMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateButtonReplyMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_TemplateButtonReplyMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_TemplateButtonReplyMessage*>(&to_msg);
+  auto& from = static_cast<const Message_TemplateButtonReplyMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateButtonReplyMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_selectedid(from._internal_selectedid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.selectedindex_ = from._impl_.selectedindex_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_TemplateButtonReplyMessage::CopyFrom(const Message_TemplateButtonReplyMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateButtonReplyMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_TemplateButtonReplyMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_TemplateButtonReplyMessage::InternalSwap(Message_TemplateButtonReplyMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.selectedid_, lhs_arena,
+      &other->_impl_.selectedid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.selecteddisplaytext_, lhs_arena,
+      &other->_impl_.selecteddisplaytext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.selectedindex_)
+      + sizeof(Message_TemplateButtonReplyMessage::_impl_.selectedindex_)
+      - PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateButtonReplyMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[132]);
+}
+
+// ===================================================================
+
+class Message_TemplateMessage_FourRowTemplate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_TemplateMessage_FourRowTemplate>()._impl_._has_bits_);
+  static const ::proto::Message_HighlyStructuredMessage& content(const Message_TemplateMessage_FourRowTemplate* msg);
+  static void set_has_content(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_HighlyStructuredMessage& footer(const Message_TemplateMessage_FourRowTemplate* msg);
+  static void set_has_footer(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_FourRowTemplate* msg);
+  static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg);
+  static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_FourRowTemplate* msg);
+  static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_FourRowTemplate* msg);
+  static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_FourRowTemplate* msg);
+};
+
+const ::proto::Message_HighlyStructuredMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::content(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.content_;
+}
+const ::proto::Message_HighlyStructuredMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::footer(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.footer_;
+}
+const ::proto::Message_DocumentMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.title_.documentmessage_;
+}
+const ::proto::Message_HighlyStructuredMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.title_.highlystructuredmessage_;
+}
+const ::proto::Message_ImageMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.title_.imagemessage_;
+}
+const ::proto::Message_VideoMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.title_.videomessage_;
+}
+const ::proto::Message_LocationMessage&
+Message_TemplateMessage_FourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_FourRowTemplate* msg) {
+  return *msg->_impl_.title_.locationmessage_;
+}
+void Message_TemplateMessage_FourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (documentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
+    if (message_arena != submessage_arena) {
+      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentmessage, submessage_arena);
+    }
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+}
+void Message_TemplateMessage_FourRowTemplate::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (highlystructuredmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage);
+    if (message_arena != submessage_arena) {
+      highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, highlystructuredmessage, submessage_arena);
+    }
+    set_has_highlystructuredmessage();
+    _impl_.title_.highlystructuredmessage_ = highlystructuredmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+}
+void Message_TemplateMessage_FourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (imagemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
+    if (message_arena != submessage_arena) {
+      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, imagemessage, submessage_arena);
+    }
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+}
+void Message_TemplateMessage_FourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (videomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
+    if (message_arena != submessage_arena) {
+      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, videomessage, submessage_arena);
+    }
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+}
+void Message_TemplateMessage_FourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (locationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage);
+    if (message_arena != submessage_arena) {
+      locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, locationmessage, submessage_arena);
+    }
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+}
+Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.FourRowTemplate)
+}
+Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_TemplateMessage_FourRowTemplate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){from._impl_.buttons_}
+    , decltype(_impl_.content_){nullptr}
+    , decltype(_impl_.footer_){nullptr}
+    , decltype(_impl_.title_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_content()) {
+    _this->_impl_.content_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.content_);
+  }
+  if (from._internal_has_footer()) {
+    _this->_impl_.footer_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.footer_);
+  }
+  clear_has_title();
+  switch (from.title_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kHighlyStructuredMessage: {
+      _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_highlystructuredmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.FourRowTemplate)
+}
+
+inline void Message_TemplateMessage_FourRowTemplate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.buttons_){arena}
+    , decltype(_impl_.content_){nullptr}
+    , decltype(_impl_.footer_){nullptr}
+    , decltype(_impl_.title_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_title();
+}
+
+Message_TemplateMessage_FourRowTemplate::~Message_TemplateMessage_FourRowTemplate() {
+  // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.FourRowTemplate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_TemplateMessage_FourRowTemplate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.buttons_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.content_;
+  if (this != internal_default_instance()) delete _impl_.footer_;
+  if (has_title()) {
+    clear_title();
+  }
+}
+
+void Message_TemplateMessage_FourRowTemplate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_TemplateMessage_FourRowTemplate::clear_title() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.FourRowTemplate)
+  switch (title_case()) {
+    case kDocumentMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.documentmessage_;
+      }
+      break;
+    }
+    case kHighlyStructuredMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.highlystructuredmessage_;
+      }
+      break;
+    }
+    case kImageMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.imagemessage_;
+      }
+      break;
+    }
+    case kVideoMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.videomessage_;
+      }
+      break;
+    }
+    case kLocationMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.locationmessage_;
+      }
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = TITLE_NOT_SET;
+}
+
+
+void Message_TemplateMessage_FourRowTemplate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.FourRowTemplate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.buttons_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.content_ != nullptr);
+      _impl_.content_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.footer_ != nullptr);
+      _impl_.footer_->Clear();
+    }
+  }
+  clear_title();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_TemplateMessage_FourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.Message.DocumentMessage documentMessage = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.ImageMessage imageMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.VideoMessage videoMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.LocationMessage locationMessage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage content = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_content(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage footer = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.TemplateButton buttons = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_buttons(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_TemplateMessage_FourRowTemplate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.FourRowTemplate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (title_case()) {
+    case kDocumentMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::documentmessage(this),
+          _Internal::documentmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kHighlyStructuredMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::highlystructuredmessage(this),
+          _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kImageMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::imagemessage(this),
+          _Internal::imagemessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kVideoMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, _Internal::videomessage(this),
+          _Internal::videomessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kLocationMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, _Internal::locationmessage(this),
+          _Internal::locationmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.HighlyStructuredMessage content = 6;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::content(this),
+        _Internal::content(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.HighlyStructuredMessage footer = 7;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::footer(this),
+        _Internal::footer(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.TemplateButton buttons = 8;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_buttons_size()); i < n; i++) {
+    const auto& repfield = this->_internal_buttons(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.TemplateMessage.FourRowTemplate)
+  return target;
+}
+
+size_t Message_TemplateMessage_FourRowTemplate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.FourRowTemplate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.TemplateButton buttons = 8;
+  total_size += 1UL * this->_internal_buttons_size();
+  for (const auto& msg : this->_impl_.buttons_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.Message.HighlyStructuredMessage content = 6;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.content_);
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage footer = 7;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.footer_);
+    }
+
+  }
+  switch (title_case()) {
+    // .proto.Message.DocumentMessage documentMessage = 1;
+    case kDocumentMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.documentmessage_);
+      break;
+    }
+    // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
+    case kHighlyStructuredMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.highlystructuredmessage_);
+      break;
+    }
+    // .proto.Message.ImageMessage imageMessage = 3;
+    case kImageMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.imagemessage_);
+      break;
+    }
+    // .proto.Message.VideoMessage videoMessage = 4;
+    case kVideoMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.videomessage_);
+      break;
+    }
+    // .proto.Message.LocationMessage locationMessage = 5;
+    case kLocationMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.locationmessage_);
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_FourRowTemplate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_TemplateMessage_FourRowTemplate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_FourRowTemplate::GetClassData() const { return &_class_data_; }
+
+
+void Message_TemplateMessage_FourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_TemplateMessage_FourRowTemplate*>(&to_msg);
+  auto& from = static_cast<const Message_TemplateMessage_FourRowTemplate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.FourRowTemplate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_content()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_content());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_footer()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_footer());
+    }
+  }
+  switch (from.title_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kHighlyStructuredMessage: {
+      _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_highlystructuredmessage());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_TemplateMessage_FourRowTemplate::CopyFrom(const Message_TemplateMessage_FourRowTemplate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.FourRowTemplate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_TemplateMessage_FourRowTemplate::IsInitialized() const {
+  return true;
+}
+
+void Message_TemplateMessage_FourRowTemplate::InternalSwap(Message_TemplateMessage_FourRowTemplate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.buttons_.InternalSwap(&other->_impl_.buttons_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.footer_)
+      + sizeof(Message_TemplateMessage_FourRowTemplate::_impl_.footer_)
+      - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.content_)>(
+          reinterpret_cast<char*>(&_impl_.content_),
+          reinterpret_cast<char*>(&other->_impl_.content_));
+  swap(_impl_.title_, other->_impl_.title_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_FourRowTemplate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[133]);
+}
+
+// ===================================================================
+
+class Message_TemplateMessage_HydratedFourRowTemplate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_TemplateMessage_HydratedFourRowTemplate>()._impl_._has_bits_);
+  static void set_has_hydratedcontenttext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_hydratedfootertext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_templateid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg);
+  static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg);
+  static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg);
+  static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg);
+};
+
+const ::proto::Message_DocumentMessage&
+Message_TemplateMessage_HydratedFourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) {
+  return *msg->_impl_.title_.documentmessage_;
+}
+const ::proto::Message_ImageMessage&
+Message_TemplateMessage_HydratedFourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) {
+  return *msg->_impl_.title_.imagemessage_;
+}
+const ::proto::Message_VideoMessage&
+Message_TemplateMessage_HydratedFourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) {
+  return *msg->_impl_.title_.videomessage_;
+}
+const ::proto::Message_LocationMessage&
+Message_TemplateMessage_HydratedFourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) {
+  return *msg->_impl_.title_.locationmessage_;
+}
+void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (documentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
+    if (message_arena != submessage_arena) {
+      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentmessage, submessage_arena);
+    }
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+}
+void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (imagemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
+    if (message_arena != submessage_arena) {
+      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, imagemessage, submessage_arena);
+    }
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+}
+void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (videomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
+    if (message_arena != submessage_arena) {
+      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, videomessage, submessage_arena);
+    }
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+}
+void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_title();
+  if (locationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage);
+    if (message_arena != submessage_arena) {
+      locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, locationmessage, submessage_arena);
+    }
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+}
+Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+}
+Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_TemplateMessage_HydratedFourRowTemplate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.hydratedbuttons_){from._impl_.hydratedbuttons_}
+    , decltype(_impl_.hydratedcontenttext_){}
+    , decltype(_impl_.hydratedfootertext_){}
+    , decltype(_impl_.templateid_){}
+    , decltype(_impl_.title_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.hydratedcontenttext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_hydratedcontenttext()) {
+    _this->_impl_.hydratedcontenttext_.Set(from._internal_hydratedcontenttext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.hydratedfootertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_hydratedfootertext()) {
+    _this->_impl_.hydratedfootertext_.Set(from._internal_hydratedfootertext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.templateid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.templateid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_templateid()) {
+    _this->_impl_.templateid_.Set(from._internal_templateid(), 
+      _this->GetArenaForAllocation());
+  }
+  clear_has_title();
+  switch (from.title_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kHydratedTitleText: {
+      _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+}
+
+inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.hydratedbuttons_){arena}
+    , decltype(_impl_.hydratedcontenttext_){}
+    , decltype(_impl_.hydratedfootertext_){}
+    , decltype(_impl_.templateid_){}
+    , decltype(_impl_.title_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  _impl_.hydratedcontenttext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.hydratedfootertext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.templateid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.templateid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  clear_has_title();
+}
+
+Message_TemplateMessage_HydratedFourRowTemplate::~Message_TemplateMessage_HydratedFourRowTemplate() {
+  // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hydratedbuttons_.~RepeatedPtrField();
+  _impl_.hydratedcontenttext_.Destroy();
+  _impl_.hydratedfootertext_.Destroy();
+  _impl_.templateid_.Destroy();
+  if (has_title()) {
+    clear_title();
+  }
+}
+
+void Message_TemplateMessage_HydratedFourRowTemplate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_TemplateMessage_HydratedFourRowTemplate::clear_title() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  switch (title_case()) {
+    case kDocumentMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.documentmessage_;
+      }
+      break;
+    }
+    case kHydratedTitleText: {
+      _impl_.title_.hydratedtitletext_.Destroy();
+      break;
+    }
+    case kImageMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.imagemessage_;
+      }
+      break;
+    }
+    case kVideoMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.videomessage_;
+      }
+      break;
+    }
+    case kLocationMessage: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.title_.locationmessage_;
+      }
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = TITLE_NOT_SET;
+}
+
+
+void Message_TemplateMessage_HydratedFourRowTemplate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hydratedbuttons_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.hydratedcontenttext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.hydratedfootertext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.templateid_.ClearNonDefaultToEmpty();
+    }
+  }
+  clear_title();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_TemplateMessage_HydratedFourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.Message.DocumentMessage documentMessage = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string hydratedTitleText = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_hydratedtitletext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.ImageMessage imageMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.VideoMessage videoMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.LocationMessage locationMessage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string hydratedContentText = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_hydratedcontenttext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string hydratedFooterText = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_hydratedfootertext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.HydratedTemplateButton hydratedButtons = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_hydratedbuttons(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string templateId = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_templateid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_TemplateMessage_HydratedFourRowTemplate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (title_case()) {
+    case kDocumentMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::documentmessage(this),
+          _Internal::documentmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kHydratedTitleText: {
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+        this->_internal_hydratedtitletext().data(), static_cast<int>(this->_internal_hydratedtitletext().length()),
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+        "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText");
+      target = stream->WriteStringMaybeAliased(
+          2, this->_internal_hydratedtitletext(), target);
+      break;
+    }
+    case kImageMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::imagemessage(this),
+          _Internal::imagemessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kVideoMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, _Internal::videomessage(this),
+          _Internal::videomessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kLocationMessage: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, _Internal::locationmessage(this),
+          _Internal::locationmessage(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string hydratedContentText = 6;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_hydratedcontenttext().data(), static_cast<int>(this->_internal_hydratedcontenttext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText");
+    target = stream->WriteStringMaybeAliased(
+        6, this->_internal_hydratedcontenttext(), target);
+  }
+
+  // optional string hydratedFooterText = 7;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_hydratedfootertext().data(), static_cast<int>(this->_internal_hydratedfootertext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_hydratedfootertext(), target);
+  }
+
+  // repeated .proto.HydratedTemplateButton hydratedButtons = 8;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_hydratedbuttons_size()); i < n; i++) {
+    const auto& repfield = this->_internal_hydratedbuttons(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string templateId = 9;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_templateid().data(), static_cast<int>(this->_internal_templateid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_templateid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  return target;
+}
+
+size_t Message_TemplateMessage_HydratedFourRowTemplate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.HydratedTemplateButton hydratedButtons = 8;
+  total_size += 1UL * this->_internal_hydratedbuttons_size();
+  for (const auto& msg : this->_impl_.hydratedbuttons_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string hydratedContentText = 6;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_hydratedcontenttext());
+    }
+
+    // optional string hydratedFooterText = 7;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_hydratedfootertext());
+    }
+
+    // optional string templateId = 9;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_templateid());
+    }
+
+  }
+  switch (title_case()) {
+    // .proto.Message.DocumentMessage documentMessage = 1;
+    case kDocumentMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.documentmessage_);
+      break;
+    }
+    // string hydratedTitleText = 2;
+    case kHydratedTitleText: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_hydratedtitletext());
+      break;
+    }
+    // .proto.Message.ImageMessage imageMessage = 3;
+    case kImageMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.imagemessage_);
+      break;
+    }
+    // .proto.Message.VideoMessage videoMessage = 4;
+    case kVideoMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.videomessage_);
+      break;
+    }
+    // .proto.Message.LocationMessage locationMessage = 5;
+    case kLocationMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.title_.locationmessage_);
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_HydratedFourRowTemplate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_HydratedFourRowTemplate::GetClassData() const { return &_class_data_; }
+
+
+void Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_TemplateMessage_HydratedFourRowTemplate*>(&to_msg);
+  auto& from = static_cast<const Message_TemplateMessage_HydratedFourRowTemplate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.hydratedbuttons_.MergeFrom(from._impl_.hydratedbuttons_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_hydratedcontenttext(from._internal_hydratedcontenttext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_hydratedfootertext(from._internal_hydratedfootertext());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_templateid(from._internal_templateid());
+    }
+  }
+  switch (from.title_case()) {
+    case kDocumentMessage: {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+      break;
+    }
+    case kHydratedTitleText: {
+      _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext());
+      break;
+    }
+    case kImageMessage: {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+      break;
+    }
+    case kVideoMessage: {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+      break;
+    }
+    case kLocationMessage: {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+      break;
+    }
+    case TITLE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_TemplateMessage_HydratedFourRowTemplate::CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_TemplateMessage_HydratedFourRowTemplate::IsInitialized() const {
+  return true;
+}
+
+void Message_TemplateMessage_HydratedFourRowTemplate::InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.hydratedbuttons_.InternalSwap(&other->_impl_.hydratedbuttons_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hydratedcontenttext_, lhs_arena,
+      &other->_impl_.hydratedcontenttext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hydratedfootertext_, lhs_arena,
+      &other->_impl_.hydratedfootertext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.templateid_, lhs_arena,
+      &other->_impl_.templateid_, rhs_arena
+  );
+  swap(_impl_.title_, other->_impl_.title_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_HydratedFourRowTemplate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[134]);
+}
+
+// ===================================================================
+
+class Message_TemplateMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_TemplateMessage>()._impl_._has_bits_);
+  static const ::proto::ContextInfo& contextinfo(const Message_TemplateMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate(const Message_TemplateMessage* msg);
+  static void set_has_hydratedtemplate(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate(const Message_TemplateMessage* msg);
+  static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate(const Message_TemplateMessage* msg);
+};
+
+const ::proto::ContextInfo&
+Message_TemplateMessage::_Internal::contextinfo(const Message_TemplateMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+const ::proto::Message_TemplateMessage_HydratedFourRowTemplate&
+Message_TemplateMessage::_Internal::hydratedtemplate(const Message_TemplateMessage* msg) {
+  return *msg->_impl_.hydratedtemplate_;
+}
+const ::proto::Message_TemplateMessage_FourRowTemplate&
+Message_TemplateMessage::_Internal::fourrowtemplate(const Message_TemplateMessage* msg) {
+  return *msg->_impl_.format_.fourrowtemplate_;
+}
+const ::proto::Message_TemplateMessage_HydratedFourRowTemplate&
+Message_TemplateMessage::_Internal::hydratedfourrowtemplate(const Message_TemplateMessage* msg) {
+  return *msg->_impl_.format_.hydratedfourrowtemplate_;
+}
+void Message_TemplateMessage::set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_format();
+  if (fourrowtemplate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fourrowtemplate);
+    if (message_arena != submessage_arena) {
+      fourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fourrowtemplate, submessage_arena);
+    }
+    set_has_fourrowtemplate();
+    _impl_.format_.fourrowtemplate_ = fourrowtemplate;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.fourRowTemplate)
+}
+void Message_TemplateMessage::set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_format();
+  if (hydratedfourrowtemplate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedfourrowtemplate);
+    if (message_arena != submessage_arena) {
+      hydratedfourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, hydratedfourrowtemplate, submessage_arena);
+    }
+    set_has_hydratedfourrowtemplate();
+    _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+}
+Message_TemplateMessage::Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage)
+}
+Message_TemplateMessage::Message_TemplateMessage(const Message_TemplateMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_TemplateMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.hydratedtemplate_){nullptr}
+    , decltype(_impl_.format_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  if (from._internal_has_hydratedtemplate()) {
+    _this->_impl_.hydratedtemplate_ = new ::proto::Message_TemplateMessage_HydratedFourRowTemplate(*from._impl_.hydratedtemplate_);
+  }
+  clear_has_format();
+  switch (from.format_case()) {
+    case kFourRowTemplate: {
+      _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom(
+          from._internal_fourrowtemplate());
+      break;
+    }
+    case kHydratedFourRowTemplate: {
+      _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom(
+          from._internal_hydratedfourrowtemplate());
+      break;
+    }
+    case FORMAT_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage)
+}
+
+inline void Message_TemplateMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.hydratedtemplate_){nullptr}
+    , decltype(_impl_.format_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_format();
+}
+
+Message_TemplateMessage::~Message_TemplateMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_TemplateMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+  if (this != internal_default_instance()) delete _impl_.hydratedtemplate_;
+  if (has_format()) {
+    clear_format();
+  }
+}
+
+void Message_TemplateMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_TemplateMessage::clear_format() {
+// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage)
+  switch (format_case()) {
+    case kFourRowTemplate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.format_.fourrowtemplate_;
+      }
+      break;
+    }
+    case kHydratedFourRowTemplate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.format_.hydratedfourrowtemplate_;
+      }
+      break;
+    }
+    case FORMAT_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = FORMAT_NOT_SET;
+}
+
+
+void Message_TemplateMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.hydratedtemplate_ != nullptr);
+      _impl_.hydratedtemplate_->Clear();
+    }
+  }
+  clear_format();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_TemplateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fourrowtemplate(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_hydratedfourrowtemplate(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_hydratedtemplate(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_TemplateMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (format_case()) {
+    case kFourRowTemplate: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::fourrowtemplate(this),
+          _Internal::fourrowtemplate(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kHydratedFourRowTemplate: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::hydratedfourrowtemplate(this),
+          _Internal::hydratedfourrowtemplate(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.ContextInfo contextInfo = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::hydratedtemplate(this),
+        _Internal::hydratedtemplate(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.TemplateMessage)
+  return target;
+}
+
+size_t Message_TemplateMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.ContextInfo contextInfo = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.hydratedtemplate_);
+    }
+
+  }
+  switch (format_case()) {
+    // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
+    case kFourRowTemplate: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.format_.fourrowtemplate_);
+      break;
+    }
+    // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
+    case kHydratedFourRowTemplate: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.format_.hydratedfourrowtemplate_);
+      break;
+    }
+    case FORMAT_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_TemplateMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_TemplateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_TemplateMessage*>(&to_msg);
+  auto& from = static_cast<const Message_TemplateMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_hydratedtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom(
+          from._internal_hydratedtemplate());
+    }
+  }
+  switch (from.format_case()) {
+    case kFourRowTemplate: {
+      _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom(
+          from._internal_fourrowtemplate());
+      break;
+    }
+    case kHydratedFourRowTemplate: {
+      _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom(
+          from._internal_hydratedfourrowtemplate());
+      break;
+    }
+    case FORMAT_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_TemplateMessage::CopyFrom(const Message_TemplateMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_TemplateMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_TemplateMessage::InternalSwap(Message_TemplateMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.hydratedtemplate_)
+      + sizeof(Message_TemplateMessage::_impl_.hydratedtemplate_)
+      - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+  swap(_impl_.format_, other->_impl_.format_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[135]);
+}
+
+// ===================================================================
+
+class Message_VideoMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message_VideoMessage>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_seconds(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_gifplayback(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_jpegthumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::ContextInfo& contextinfo(const Message_VideoMessage* msg);
+  static void set_has_contextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_streamingsidecar(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_gifattribution(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_viewonce(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_thumbnaildirectpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_thumbnailsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_thumbnailencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_staticurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+};
+
+const ::proto::ContextInfo&
+Message_VideoMessage::_Internal::contextinfo(const Message_VideoMessage* msg) {
+  return *msg->_impl_.contextinfo_;
+}
+Message_VideoMessage::Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message.VideoMessage)
+}
+Message_VideoMessage::Message_VideoMessage(const Message_VideoMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message_VideoMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.streamingsidecar_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.staticurl_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.seconds_){}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.gifplayback_){}
+    , decltype(_impl_.viewonce_){}
+    , decltype(_impl_.mediakeytimestamp_){}
+    , decltype(_impl_.gifattribution_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_jpegthumbnail()) {
+    _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.streamingsidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_streamingsidecar()) {
+    _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnaildirectpath()) {
+    _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailsha256()) {
+    _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_thumbnailencsha256()) {
+    _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.staticurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_staticurl()) {
+    _this->_impl_.staticurl_.Set(from._internal_staticurl(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_contextinfo()) {
+    _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_);
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.gifattribution_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.gifattribution_));
+  // @@protoc_insertion_point(copy_constructor:proto.Message.VideoMessage)
+}
+
+inline void Message_VideoMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.interactiveannotations_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.jpegthumbnail_){}
+    , decltype(_impl_.streamingsidecar_){}
+    , decltype(_impl_.thumbnaildirectpath_){}
+    , decltype(_impl_.thumbnailsha256_){}
+    , decltype(_impl_.thumbnailencsha256_){}
+    , decltype(_impl_.staticurl_){}
+    , decltype(_impl_.contextinfo_){nullptr}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.seconds_){0u}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.gifplayback_){false}
+    , decltype(_impl_.viewonce_){false}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+    , decltype(_impl_.gifattribution_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.jpegthumbnail_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.streamingsidecar_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnaildirectpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.thumbnailencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.staticurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message_VideoMessage::~Message_VideoMessage() {
+  // @@protoc_insertion_point(destructor:proto.Message.VideoMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message_VideoMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.interactiveannotations_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.caption_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+  _impl_.jpegthumbnail_.Destroy();
+  _impl_.streamingsidecar_.Destroy();
+  _impl_.thumbnaildirectpath_.Destroy();
+  _impl_.thumbnailsha256_.Destroy();
+  _impl_.thumbnailencsha256_.Destroy();
+  _impl_.staticurl_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.contextinfo_;
+}
+
+void Message_VideoMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message_VideoMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message.VideoMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.interactiveannotations_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.jpegthumbnail_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.streamingsidecar_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.thumbnailsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _impl_.staticurl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr);
+      _impl_.contextinfo_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000c000u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.seconds_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.seconds_));
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    ::memset(&_impl_.height_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.gifattribution_) -
+        reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.gifattribution_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message_VideoMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 seconds = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_seconds(&has_bits);
+          _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool gifPlayback = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_gifplayback(&has_bits);
+          _impl_.gifplayback_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes jpegThumbnail = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_jpegthumbnail();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ContextInfo contextInfo = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes streamingSidecar = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          auto str = _internal_mutable_streamingsidecar();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::Message_VideoMessage_Attribution_IsValid(val))) {
+            _internal_set_gifattribution(static_cast<::proto::Message_VideoMessage_Attribution>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool viewOnce = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          _Internal::set_has_viewonce(&has_bits);
+          _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string thumbnailDirectPath = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_thumbnaildirectpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.thumbnailDirectPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailSha256 = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          auto str = _internal_mutable_thumbnailsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes thumbnailEncSha256 = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          auto str = _internal_mutable_thumbnailencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string staticUrl = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          auto str = _internal_mutable_staticurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.staticUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message_VideoMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message.VideoMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string mimetype = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_mimetype(), target);
+  }
+
+  // optional bytes fileSha256 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_filesha256(), target);
+  }
+
+  // optional uint64 fileLength = 4;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target);
+  }
+
+  // optional uint32 seconds = 5;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target);
+  }
+
+  // optional bytes mediaKey = 6;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_mediakey(), target);
+  }
+
+  // optional string caption = 7;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.caption");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_caption(), target);
+  }
+
+  // optional bool gifPlayback = 8;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_gifplayback(), target);
+  }
+
+  // optional uint32 height = 9;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_height(), target);
+  }
+
+  // optional uint32 width = 10;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_width(), target);
+  }
+
+  // optional bytes fileEncSha256 = 11;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        11, this->_internal_fileencsha256(), target);
+  }
+
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_interactiveannotations_size()); i < n; i++) {
+    const auto& repfield = this->_internal_interactiveannotations(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string directPath = 13;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.directPath");
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_directpath(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 14;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(14, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional bytes jpegThumbnail = 16;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        16, this->_internal_jpegthumbnail(), target);
+  }
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::contextinfo(this),
+        _Internal::contextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes streamingSidecar = 18;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->WriteBytesMaybeAliased(
+        18, this->_internal_streamingsidecar(), target);
+  }
+
+  // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      19, this->_internal_gifattribution(), target);
+  }
+
+  // optional bool viewOnce = 20;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(20, this->_internal_viewonce(), target);
+  }
+
+  // optional string thumbnailDirectPath = 21;
+  if (cached_has_bits & 0x00000200u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_thumbnaildirectpath().data(), static_cast<int>(this->_internal_thumbnaildirectpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.thumbnailDirectPath");
+    target = stream->WriteStringMaybeAliased(
+        21, this->_internal_thumbnaildirectpath(), target);
+  }
+
+  // optional bytes thumbnailSha256 = 22;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->WriteBytesMaybeAliased(
+        22, this->_internal_thumbnailsha256(), target);
+  }
+
+  // optional bytes thumbnailEncSha256 = 23;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->WriteBytesMaybeAliased(
+        23, this->_internal_thumbnailencsha256(), target);
+  }
+
+  // optional string staticUrl = 24;
+  if (cached_has_bits & 0x00001000u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_staticurl().data(), static_cast<int>(this->_internal_staticurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.VideoMessage.staticUrl");
+    target = stream->WriteStringMaybeAliased(
+        24, this->_internal_staticurl(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message.VideoMessage)
+  return target;
+}
+
+size_t Message_VideoMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message.VideoMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
+  total_size += 1UL * this->_internal_interactiveannotations_size();
+  for (const auto& msg : this->_impl_.interactiveannotations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string mimetype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional bytes fileSha256 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes mediaKey = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string caption = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional bytes fileEncSha256 = 11;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 13;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional bytes jpegThumbnail = 16;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_jpegthumbnail());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional bytes streamingSidecar = 18;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_streamingsidecar());
+    }
+
+    // optional string thumbnailDirectPath = 21;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_thumbnaildirectpath());
+    }
+
+    // optional bytes thumbnailSha256 = 22;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailsha256());
+    }
+
+    // optional bytes thumbnailEncSha256 = 23;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_thumbnailencsha256());
+    }
+
+    // optional string staticUrl = 24;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_staticurl());
+    }
+
+    // optional .proto.ContextInfo contextInfo = 17;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contextinfo_);
+    }
+
+    // optional uint64 fileLength = 4;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional uint32 seconds = 5;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds());
+    }
+
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    // optional uint32 height = 9;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional uint32 width = 10;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+    // optional bool gifPlayback = 8;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool viewOnce = 20;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional int64 mediaKeyTimestamp = 14;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+    // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_gifattribution());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_VideoMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message_VideoMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_VideoMessage::GetClassData() const { return &_class_data_; }
+
+
+void Message_VideoMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message_VideoMessage*>(&to_msg);
+  auto& from = static_cast<const Message_VideoMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.VideoMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_streamingsidecar(from._internal_streamingsidecar());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_set_staticurl(from._internal_staticurl());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom(
+          from._internal_contextinfo());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.seconds_ = from._impl_.seconds_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x003f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.gifplayback_ = from._impl_.gifplayback_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.viewonce_ = from._impl_.viewonce_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.gifattribution_ = from._impl_.gifattribution_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message_VideoMessage::CopyFrom(const Message_VideoMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.VideoMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message_VideoMessage::IsInitialized() const {
+  return true;
+}
+
+void Message_VideoMessage::InternalSwap(Message_VideoMessage* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.jpegthumbnail_, lhs_arena,
+      &other->_impl_.jpegthumbnail_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.streamingsidecar_, lhs_arena,
+      &other->_impl_.streamingsidecar_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnaildirectpath_, lhs_arena,
+      &other->_impl_.thumbnaildirectpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailsha256_, lhs_arena,
+      &other->_impl_.thumbnailsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.thumbnailencsha256_, lhs_arena,
+      &other->_impl_.thumbnailencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.staticurl_, lhs_arena,
+      &other->_impl_.staticurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.gifattribution_)
+      + sizeof(Message_VideoMessage::_impl_.gifattribution_)
+      - PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.contextinfo_)>(
+          reinterpret_cast<char*>(&_impl_.contextinfo_),
+          reinterpret_cast<char*>(&other->_impl_.contextinfo_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message_VideoMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[136]);
+}
+
+// ===================================================================
+
+class Message::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Message>()._impl_._has_bits_);
+  static void set_has_conversation(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage(const Message* msg);
+  static void set_has_senderkeydistributionmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message_ImageMessage& imagemessage(const Message* msg);
+  static void set_has_imagemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::Message_ContactMessage& contactmessage(const Message* msg);
+  static void set_has_contactmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Message_LocationMessage& locationmessage(const Message* msg);
+  static void set_has_locationmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::Message_ExtendedTextMessage& extendedtextmessage(const Message* msg);
+  static void set_has_extendedtextmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::Message_DocumentMessage& documentmessage(const Message* msg);
+  static void set_has_documentmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::Message_AudioMessage& audiomessage(const Message* msg);
+  static void set_has_audiomessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::Message_VideoMessage& videomessage(const Message* msg);
+  static void set_has_videomessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::Message_Call& call(const Message* msg);
+  static void set_has_call(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static const ::proto::Message_Chat& chat(const Message* msg);
+  static void set_has_chat(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static const ::proto::Message_ProtocolMessage& protocolmessage(const Message* msg);
+  static void set_has_protocolmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::Message_ContactsArrayMessage& contactsarraymessage(const Message* msg);
+  static void set_has_contactsarraymessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message* msg);
+  static void set_has_highlystructuredmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage(const Message* msg);
+  static void set_has_fastratchetkeysenderkeydistributionmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static const ::proto::Message_SendPaymentMessage& sendpaymentmessage(const Message* msg);
+  static void set_has_sendpaymentmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static const ::proto::Message_LiveLocationMessage& livelocationmessage(const Message* msg);
+  static void set_has_livelocationmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static const ::proto::Message_RequestPaymentMessage& requestpaymentmessage(const Message* msg);
+  static void set_has_requestpaymentmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage(const Message* msg);
+  static void set_has_declinepaymentrequestmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage(const Message* msg);
+  static void set_has_cancelpaymentrequestmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static const ::proto::Message_TemplateMessage& templatemessage(const Message* msg);
+  static void set_has_templatemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static const ::proto::Message_StickerMessage& stickermessage(const Message* msg);
+  static void set_has_stickermessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static const ::proto::Message_GroupInviteMessage& groupinvitemessage(const Message* msg);
+  static void set_has_groupinvitemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage(const Message* msg);
+  static void set_has_templatebuttonreplymessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static const ::proto::Message_ProductMessage& productmessage(const Message* msg);
+  static void set_has_productmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 16777216u;
+  }
+  static const ::proto::Message_DeviceSentMessage& devicesentmessage(const Message* msg);
+  static void set_has_devicesentmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 33554432u;
+  }
+  static const ::proto::MessageContextInfo& messagecontextinfo(const Message* msg);
+  static void set_has_messagecontextinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 67108864u;
+  }
+  static const ::proto::Message_ListMessage& listmessage(const Message* msg);
+  static void set_has_listmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 134217728u;
+  }
+  static const ::proto::Message_FutureProofMessage& viewoncemessage(const Message* msg);
+  static void set_has_viewoncemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 268435456u;
+  }
+  static const ::proto::Message_OrderMessage& ordermessage(const Message* msg);
+  static void set_has_ordermessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 536870912u;
+  }
+  static const ::proto::Message_ListResponseMessage& listresponsemessage(const Message* msg);
+  static void set_has_listresponsemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 1073741824u;
+  }
+  static const ::proto::Message_FutureProofMessage& ephemeralmessage(const Message* msg);
+  static void set_has_ephemeralmessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 2147483648u;
+  }
+  static const ::proto::Message_InvoiceMessage& invoicemessage(const Message* msg);
+  static void set_has_invoicemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 1u;
+  }
+  static const ::proto::Message_ButtonsMessage& buttonsmessage(const Message* msg);
+  static void set_has_buttonsmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 2u;
+  }
+  static const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage(const Message* msg);
+  static void set_has_buttonsresponsemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 4u;
+  }
+  static const ::proto::Message_PaymentInviteMessage& paymentinvitemessage(const Message* msg);
+  static void set_has_paymentinvitemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 8u;
+  }
+  static const ::proto::Message_InteractiveMessage& interactivemessage(const Message* msg);
+  static void set_has_interactivemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 16u;
+  }
+  static const ::proto::Message_ReactionMessage& reactionmessage(const Message* msg);
+  static void set_has_reactionmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 32u;
+  }
+  static const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage(const Message* msg);
+  static void set_has_stickersyncrmrmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 64u;
+  }
+  static const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage(const Message* msg);
+  static void set_has_interactiveresponsemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 128u;
+  }
+  static const ::proto::Message_PollCreationMessage& pollcreationmessage(const Message* msg);
+  static void set_has_pollcreationmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 256u;
+  }
+  static const ::proto::Message_PollUpdateMessage& pollupdatemessage(const Message* msg);
+  static void set_has_pollupdatemessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 512u;
+  }
+  static const ::proto::Message_KeepInChatMessage& keepinchatmessage(const Message* msg);
+  static void set_has_keepinchatmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 1024u;
+  }
+  static const ::proto::Message_FutureProofMessage& documentwithcaptionmessage(const Message* msg);
+  static void set_has_documentwithcaptionmessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 2048u;
+  }
+  static const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage(const Message* msg);
+  static void set_has_requestphonenumbermessage(HasBits* has_bits) {
+    (*has_bits)[1] |= 4096u;
+  }
+  static const ::proto::Message_FutureProofMessage& viewoncemessagev2(const Message* msg);
+  static void set_has_viewoncemessagev2(HasBits* has_bits) {
+    (*has_bits)[1] |= 8192u;
+  }
+};
+
+const ::proto::Message_SenderKeyDistributionMessage&
+Message::_Internal::senderkeydistributionmessage(const Message* msg) {
+  return *msg->_impl_.senderkeydistributionmessage_;
+}
+const ::proto::Message_ImageMessage&
+Message::_Internal::imagemessage(const Message* msg) {
+  return *msg->_impl_.imagemessage_;
+}
+const ::proto::Message_ContactMessage&
+Message::_Internal::contactmessage(const Message* msg) {
+  return *msg->_impl_.contactmessage_;
+}
+const ::proto::Message_LocationMessage&
+Message::_Internal::locationmessage(const Message* msg) {
+  return *msg->_impl_.locationmessage_;
+}
+const ::proto::Message_ExtendedTextMessage&
+Message::_Internal::extendedtextmessage(const Message* msg) {
+  return *msg->_impl_.extendedtextmessage_;
+}
+const ::proto::Message_DocumentMessage&
+Message::_Internal::documentmessage(const Message* msg) {
+  return *msg->_impl_.documentmessage_;
+}
+const ::proto::Message_AudioMessage&
+Message::_Internal::audiomessage(const Message* msg) {
+  return *msg->_impl_.audiomessage_;
+}
+const ::proto::Message_VideoMessage&
+Message::_Internal::videomessage(const Message* msg) {
+  return *msg->_impl_.videomessage_;
+}
+const ::proto::Message_Call&
+Message::_Internal::call(const Message* msg) {
+  return *msg->_impl_.call_;
+}
+const ::proto::Message_Chat&
+Message::_Internal::chat(const Message* msg) {
+  return *msg->_impl_.chat_;
+}
+const ::proto::Message_ProtocolMessage&
+Message::_Internal::protocolmessage(const Message* msg) {
+  return *msg->_impl_.protocolmessage_;
+}
+const ::proto::Message_ContactsArrayMessage&
+Message::_Internal::contactsarraymessage(const Message* msg) {
+  return *msg->_impl_.contactsarraymessage_;
+}
+const ::proto::Message_HighlyStructuredMessage&
+Message::_Internal::highlystructuredmessage(const Message* msg) {
+  return *msg->_impl_.highlystructuredmessage_;
+}
+const ::proto::Message_SenderKeyDistributionMessage&
+Message::_Internal::fastratchetkeysenderkeydistributionmessage(const Message* msg) {
+  return *msg->_impl_.fastratchetkeysenderkeydistributionmessage_;
+}
+const ::proto::Message_SendPaymentMessage&
+Message::_Internal::sendpaymentmessage(const Message* msg) {
+  return *msg->_impl_.sendpaymentmessage_;
+}
+const ::proto::Message_LiveLocationMessage&
+Message::_Internal::livelocationmessage(const Message* msg) {
+  return *msg->_impl_.livelocationmessage_;
+}
+const ::proto::Message_RequestPaymentMessage&
+Message::_Internal::requestpaymentmessage(const Message* msg) {
+  return *msg->_impl_.requestpaymentmessage_;
+}
+const ::proto::Message_DeclinePaymentRequestMessage&
+Message::_Internal::declinepaymentrequestmessage(const Message* msg) {
+  return *msg->_impl_.declinepaymentrequestmessage_;
+}
+const ::proto::Message_CancelPaymentRequestMessage&
+Message::_Internal::cancelpaymentrequestmessage(const Message* msg) {
+  return *msg->_impl_.cancelpaymentrequestmessage_;
+}
+const ::proto::Message_TemplateMessage&
+Message::_Internal::templatemessage(const Message* msg) {
+  return *msg->_impl_.templatemessage_;
+}
+const ::proto::Message_StickerMessage&
+Message::_Internal::stickermessage(const Message* msg) {
+  return *msg->_impl_.stickermessage_;
+}
+const ::proto::Message_GroupInviteMessage&
+Message::_Internal::groupinvitemessage(const Message* msg) {
+  return *msg->_impl_.groupinvitemessage_;
+}
+const ::proto::Message_TemplateButtonReplyMessage&
+Message::_Internal::templatebuttonreplymessage(const Message* msg) {
+  return *msg->_impl_.templatebuttonreplymessage_;
+}
+const ::proto::Message_ProductMessage&
+Message::_Internal::productmessage(const Message* msg) {
+  return *msg->_impl_.productmessage_;
+}
+const ::proto::Message_DeviceSentMessage&
+Message::_Internal::devicesentmessage(const Message* msg) {
+  return *msg->_impl_.devicesentmessage_;
+}
+const ::proto::MessageContextInfo&
+Message::_Internal::messagecontextinfo(const Message* msg) {
+  return *msg->_impl_.messagecontextinfo_;
+}
+const ::proto::Message_ListMessage&
+Message::_Internal::listmessage(const Message* msg) {
+  return *msg->_impl_.listmessage_;
+}
+const ::proto::Message_FutureProofMessage&
+Message::_Internal::viewoncemessage(const Message* msg) {
+  return *msg->_impl_.viewoncemessage_;
+}
+const ::proto::Message_OrderMessage&
+Message::_Internal::ordermessage(const Message* msg) {
+  return *msg->_impl_.ordermessage_;
+}
+const ::proto::Message_ListResponseMessage&
+Message::_Internal::listresponsemessage(const Message* msg) {
+  return *msg->_impl_.listresponsemessage_;
+}
+const ::proto::Message_FutureProofMessage&
+Message::_Internal::ephemeralmessage(const Message* msg) {
+  return *msg->_impl_.ephemeralmessage_;
+}
+const ::proto::Message_InvoiceMessage&
+Message::_Internal::invoicemessage(const Message* msg) {
+  return *msg->_impl_.invoicemessage_;
+}
+const ::proto::Message_ButtonsMessage&
+Message::_Internal::buttonsmessage(const Message* msg) {
+  return *msg->_impl_.buttonsmessage_;
+}
+const ::proto::Message_ButtonsResponseMessage&
+Message::_Internal::buttonsresponsemessage(const Message* msg) {
+  return *msg->_impl_.buttonsresponsemessage_;
+}
+const ::proto::Message_PaymentInviteMessage&
+Message::_Internal::paymentinvitemessage(const Message* msg) {
+  return *msg->_impl_.paymentinvitemessage_;
+}
+const ::proto::Message_InteractiveMessage&
+Message::_Internal::interactivemessage(const Message* msg) {
+  return *msg->_impl_.interactivemessage_;
+}
+const ::proto::Message_ReactionMessage&
+Message::_Internal::reactionmessage(const Message* msg) {
+  return *msg->_impl_.reactionmessage_;
+}
+const ::proto::Message_StickerSyncRMRMessage&
+Message::_Internal::stickersyncrmrmessage(const Message* msg) {
+  return *msg->_impl_.stickersyncrmrmessage_;
+}
+const ::proto::Message_InteractiveResponseMessage&
+Message::_Internal::interactiveresponsemessage(const Message* msg) {
+  return *msg->_impl_.interactiveresponsemessage_;
+}
+const ::proto::Message_PollCreationMessage&
+Message::_Internal::pollcreationmessage(const Message* msg) {
+  return *msg->_impl_.pollcreationmessage_;
+}
+const ::proto::Message_PollUpdateMessage&
+Message::_Internal::pollupdatemessage(const Message* msg) {
+  return *msg->_impl_.pollupdatemessage_;
+}
+const ::proto::Message_KeepInChatMessage&
+Message::_Internal::keepinchatmessage(const Message* msg) {
+  return *msg->_impl_.keepinchatmessage_;
+}
+const ::proto::Message_FutureProofMessage&
+Message::_Internal::documentwithcaptionmessage(const Message* msg) {
+  return *msg->_impl_.documentwithcaptionmessage_;
+}
+const ::proto::Message_RequestPhoneNumberMessage&
+Message::_Internal::requestphonenumbermessage(const Message* msg) {
+  return *msg->_impl_.requestphonenumbermessage_;
+}
+const ::proto::Message_FutureProofMessage&
+Message::_Internal::viewoncemessagev2(const Message* msg) {
+  return *msg->_impl_.viewoncemessagev2_;
+}
+Message::Message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Message)
+}
+Message::Message(const Message& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Message* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.conversation_){}
+    , decltype(_impl_.senderkeydistributionmessage_){nullptr}
+    , decltype(_impl_.imagemessage_){nullptr}
+    , decltype(_impl_.contactmessage_){nullptr}
+    , decltype(_impl_.locationmessage_){nullptr}
+    , decltype(_impl_.extendedtextmessage_){nullptr}
+    , decltype(_impl_.documentmessage_){nullptr}
+    , decltype(_impl_.audiomessage_){nullptr}
+    , decltype(_impl_.videomessage_){nullptr}
+    , decltype(_impl_.call_){nullptr}
+    , decltype(_impl_.chat_){nullptr}
+    , decltype(_impl_.protocolmessage_){nullptr}
+    , decltype(_impl_.contactsarraymessage_){nullptr}
+    , decltype(_impl_.highlystructuredmessage_){nullptr}
+    , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr}
+    , decltype(_impl_.sendpaymentmessage_){nullptr}
+    , decltype(_impl_.livelocationmessage_){nullptr}
+    , decltype(_impl_.requestpaymentmessage_){nullptr}
+    , decltype(_impl_.declinepaymentrequestmessage_){nullptr}
+    , decltype(_impl_.cancelpaymentrequestmessage_){nullptr}
+    , decltype(_impl_.templatemessage_){nullptr}
+    , decltype(_impl_.stickermessage_){nullptr}
+    , decltype(_impl_.groupinvitemessage_){nullptr}
+    , decltype(_impl_.templatebuttonreplymessage_){nullptr}
+    , decltype(_impl_.productmessage_){nullptr}
+    , decltype(_impl_.devicesentmessage_){nullptr}
+    , decltype(_impl_.messagecontextinfo_){nullptr}
+    , decltype(_impl_.listmessage_){nullptr}
+    , decltype(_impl_.viewoncemessage_){nullptr}
+    , decltype(_impl_.ordermessage_){nullptr}
+    , decltype(_impl_.listresponsemessage_){nullptr}
+    , decltype(_impl_.ephemeralmessage_){nullptr}
+    , decltype(_impl_.invoicemessage_){nullptr}
+    , decltype(_impl_.buttonsmessage_){nullptr}
+    , decltype(_impl_.buttonsresponsemessage_){nullptr}
+    , decltype(_impl_.paymentinvitemessage_){nullptr}
+    , decltype(_impl_.interactivemessage_){nullptr}
+    , decltype(_impl_.reactionmessage_){nullptr}
+    , decltype(_impl_.stickersyncrmrmessage_){nullptr}
+    , decltype(_impl_.interactiveresponsemessage_){nullptr}
+    , decltype(_impl_.pollcreationmessage_){nullptr}
+    , decltype(_impl_.pollupdatemessage_){nullptr}
+    , decltype(_impl_.keepinchatmessage_){nullptr}
+    , decltype(_impl_.documentwithcaptionmessage_){nullptr}
+    , decltype(_impl_.requestphonenumbermessage_){nullptr}
+    , decltype(_impl_.viewoncemessagev2_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.conversation_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversation_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_conversation()) {
+    _this->_impl_.conversation_.Set(from._internal_conversation(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_senderkeydistributionmessage()) {
+    _this->_impl_.senderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.senderkeydistributionmessage_);
+  }
+  if (from._internal_has_imagemessage()) {
+    _this->_impl_.imagemessage_ = new ::proto::Message_ImageMessage(*from._impl_.imagemessage_);
+  }
+  if (from._internal_has_contactmessage()) {
+    _this->_impl_.contactmessage_ = new ::proto::Message_ContactMessage(*from._impl_.contactmessage_);
+  }
+  if (from._internal_has_locationmessage()) {
+    _this->_impl_.locationmessage_ = new ::proto::Message_LocationMessage(*from._impl_.locationmessage_);
+  }
+  if (from._internal_has_extendedtextmessage()) {
+    _this->_impl_.extendedtextmessage_ = new ::proto::Message_ExtendedTextMessage(*from._impl_.extendedtextmessage_);
+  }
+  if (from._internal_has_documentmessage()) {
+    _this->_impl_.documentmessage_ = new ::proto::Message_DocumentMessage(*from._impl_.documentmessage_);
+  }
+  if (from._internal_has_audiomessage()) {
+    _this->_impl_.audiomessage_ = new ::proto::Message_AudioMessage(*from._impl_.audiomessage_);
+  }
+  if (from._internal_has_videomessage()) {
+    _this->_impl_.videomessage_ = new ::proto::Message_VideoMessage(*from._impl_.videomessage_);
+  }
+  if (from._internal_has_call()) {
+    _this->_impl_.call_ = new ::proto::Message_Call(*from._impl_.call_);
+  }
+  if (from._internal_has_chat()) {
+    _this->_impl_.chat_ = new ::proto::Message_Chat(*from._impl_.chat_);
+  }
+  if (from._internal_has_protocolmessage()) {
+    _this->_impl_.protocolmessage_ = new ::proto::Message_ProtocolMessage(*from._impl_.protocolmessage_);
+  }
+  if (from._internal_has_contactsarraymessage()) {
+    _this->_impl_.contactsarraymessage_ = new ::proto::Message_ContactsArrayMessage(*from._impl_.contactsarraymessage_);
+  }
+  if (from._internal_has_highlystructuredmessage()) {
+    _this->_impl_.highlystructuredmessage_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.highlystructuredmessage_);
+  }
+  if (from._internal_has_fastratchetkeysenderkeydistributionmessage()) {
+    _this->_impl_.fastratchetkeysenderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.fastratchetkeysenderkeydistributionmessage_);
+  }
+  if (from._internal_has_sendpaymentmessage()) {
+    _this->_impl_.sendpaymentmessage_ = new ::proto::Message_SendPaymentMessage(*from._impl_.sendpaymentmessage_);
+  }
+  if (from._internal_has_livelocationmessage()) {
+    _this->_impl_.livelocationmessage_ = new ::proto::Message_LiveLocationMessage(*from._impl_.livelocationmessage_);
+  }
+  if (from._internal_has_requestpaymentmessage()) {
+    _this->_impl_.requestpaymentmessage_ = new ::proto::Message_RequestPaymentMessage(*from._impl_.requestpaymentmessage_);
+  }
+  if (from._internal_has_declinepaymentrequestmessage()) {
+    _this->_impl_.declinepaymentrequestmessage_ = new ::proto::Message_DeclinePaymentRequestMessage(*from._impl_.declinepaymentrequestmessage_);
+  }
+  if (from._internal_has_cancelpaymentrequestmessage()) {
+    _this->_impl_.cancelpaymentrequestmessage_ = new ::proto::Message_CancelPaymentRequestMessage(*from._impl_.cancelpaymentrequestmessage_);
+  }
+  if (from._internal_has_templatemessage()) {
+    _this->_impl_.templatemessage_ = new ::proto::Message_TemplateMessage(*from._impl_.templatemessage_);
+  }
+  if (from._internal_has_stickermessage()) {
+    _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_);
+  }
+  if (from._internal_has_groupinvitemessage()) {
+    _this->_impl_.groupinvitemessage_ = new ::proto::Message_GroupInviteMessage(*from._impl_.groupinvitemessage_);
+  }
+  if (from._internal_has_templatebuttonreplymessage()) {
+    _this->_impl_.templatebuttonreplymessage_ = new ::proto::Message_TemplateButtonReplyMessage(*from._impl_.templatebuttonreplymessage_);
+  }
+  if (from._internal_has_productmessage()) {
+    _this->_impl_.productmessage_ = new ::proto::Message_ProductMessage(*from._impl_.productmessage_);
+  }
+  if (from._internal_has_devicesentmessage()) {
+    _this->_impl_.devicesentmessage_ = new ::proto::Message_DeviceSentMessage(*from._impl_.devicesentmessage_);
+  }
+  if (from._internal_has_messagecontextinfo()) {
+    _this->_impl_.messagecontextinfo_ = new ::proto::MessageContextInfo(*from._impl_.messagecontextinfo_);
+  }
+  if (from._internal_has_listmessage()) {
+    _this->_impl_.listmessage_ = new ::proto::Message_ListMessage(*from._impl_.listmessage_);
+  }
+  if (from._internal_has_viewoncemessage()) {
+    _this->_impl_.viewoncemessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessage_);
+  }
+  if (from._internal_has_ordermessage()) {
+    _this->_impl_.ordermessage_ = new ::proto::Message_OrderMessage(*from._impl_.ordermessage_);
+  }
+  if (from._internal_has_listresponsemessage()) {
+    _this->_impl_.listresponsemessage_ = new ::proto::Message_ListResponseMessage(*from._impl_.listresponsemessage_);
+  }
+  if (from._internal_has_ephemeralmessage()) {
+    _this->_impl_.ephemeralmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.ephemeralmessage_);
+  }
+  if (from._internal_has_invoicemessage()) {
+    _this->_impl_.invoicemessage_ = new ::proto::Message_InvoiceMessage(*from._impl_.invoicemessage_);
+  }
+  if (from._internal_has_buttonsmessage()) {
+    _this->_impl_.buttonsmessage_ = new ::proto::Message_ButtonsMessage(*from._impl_.buttonsmessage_);
+  }
+  if (from._internal_has_buttonsresponsemessage()) {
+    _this->_impl_.buttonsresponsemessage_ = new ::proto::Message_ButtonsResponseMessage(*from._impl_.buttonsresponsemessage_);
+  }
+  if (from._internal_has_paymentinvitemessage()) {
+    _this->_impl_.paymentinvitemessage_ = new ::proto::Message_PaymentInviteMessage(*from._impl_.paymentinvitemessage_);
+  }
+  if (from._internal_has_interactivemessage()) {
+    _this->_impl_.interactivemessage_ = new ::proto::Message_InteractiveMessage(*from._impl_.interactivemessage_);
+  }
+  if (from._internal_has_reactionmessage()) {
+    _this->_impl_.reactionmessage_ = new ::proto::Message_ReactionMessage(*from._impl_.reactionmessage_);
+  }
+  if (from._internal_has_stickersyncrmrmessage()) {
+    _this->_impl_.stickersyncrmrmessage_ = new ::proto::Message_StickerSyncRMRMessage(*from._impl_.stickersyncrmrmessage_);
+  }
+  if (from._internal_has_interactiveresponsemessage()) {
+    _this->_impl_.interactiveresponsemessage_ = new ::proto::Message_InteractiveResponseMessage(*from._impl_.interactiveresponsemessage_);
+  }
+  if (from._internal_has_pollcreationmessage()) {
+    _this->_impl_.pollcreationmessage_ = new ::proto::Message_PollCreationMessage(*from._impl_.pollcreationmessage_);
+  }
+  if (from._internal_has_pollupdatemessage()) {
+    _this->_impl_.pollupdatemessage_ = new ::proto::Message_PollUpdateMessage(*from._impl_.pollupdatemessage_);
+  }
+  if (from._internal_has_keepinchatmessage()) {
+    _this->_impl_.keepinchatmessage_ = new ::proto::Message_KeepInChatMessage(*from._impl_.keepinchatmessage_);
+  }
+  if (from._internal_has_documentwithcaptionmessage()) {
+    _this->_impl_.documentwithcaptionmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.documentwithcaptionmessage_);
+  }
+  if (from._internal_has_requestphonenumbermessage()) {
+    _this->_impl_.requestphonenumbermessage_ = new ::proto::Message_RequestPhoneNumberMessage(*from._impl_.requestphonenumbermessage_);
+  }
+  if (from._internal_has_viewoncemessagev2()) {
+    _this->_impl_.viewoncemessagev2_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessagev2_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Message)
+}
+
+inline void Message::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.conversation_){}
+    , decltype(_impl_.senderkeydistributionmessage_){nullptr}
+    , decltype(_impl_.imagemessage_){nullptr}
+    , decltype(_impl_.contactmessage_){nullptr}
+    , decltype(_impl_.locationmessage_){nullptr}
+    , decltype(_impl_.extendedtextmessage_){nullptr}
+    , decltype(_impl_.documentmessage_){nullptr}
+    , decltype(_impl_.audiomessage_){nullptr}
+    , decltype(_impl_.videomessage_){nullptr}
+    , decltype(_impl_.call_){nullptr}
+    , decltype(_impl_.chat_){nullptr}
+    , decltype(_impl_.protocolmessage_){nullptr}
+    , decltype(_impl_.contactsarraymessage_){nullptr}
+    , decltype(_impl_.highlystructuredmessage_){nullptr}
+    , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr}
+    , decltype(_impl_.sendpaymentmessage_){nullptr}
+    , decltype(_impl_.livelocationmessage_){nullptr}
+    , decltype(_impl_.requestpaymentmessage_){nullptr}
+    , decltype(_impl_.declinepaymentrequestmessage_){nullptr}
+    , decltype(_impl_.cancelpaymentrequestmessage_){nullptr}
+    , decltype(_impl_.templatemessage_){nullptr}
+    , decltype(_impl_.stickermessage_){nullptr}
+    , decltype(_impl_.groupinvitemessage_){nullptr}
+    , decltype(_impl_.templatebuttonreplymessage_){nullptr}
+    , decltype(_impl_.productmessage_){nullptr}
+    , decltype(_impl_.devicesentmessage_){nullptr}
+    , decltype(_impl_.messagecontextinfo_){nullptr}
+    , decltype(_impl_.listmessage_){nullptr}
+    , decltype(_impl_.viewoncemessage_){nullptr}
+    , decltype(_impl_.ordermessage_){nullptr}
+    , decltype(_impl_.listresponsemessage_){nullptr}
+    , decltype(_impl_.ephemeralmessage_){nullptr}
+    , decltype(_impl_.invoicemessage_){nullptr}
+    , decltype(_impl_.buttonsmessage_){nullptr}
+    , decltype(_impl_.buttonsresponsemessage_){nullptr}
+    , decltype(_impl_.paymentinvitemessage_){nullptr}
+    , decltype(_impl_.interactivemessage_){nullptr}
+    , decltype(_impl_.reactionmessage_){nullptr}
+    , decltype(_impl_.stickersyncrmrmessage_){nullptr}
+    , decltype(_impl_.interactiveresponsemessage_){nullptr}
+    , decltype(_impl_.pollcreationmessage_){nullptr}
+    , decltype(_impl_.pollupdatemessage_){nullptr}
+    , decltype(_impl_.keepinchatmessage_){nullptr}
+    , decltype(_impl_.documentwithcaptionmessage_){nullptr}
+    , decltype(_impl_.requestphonenumbermessage_){nullptr}
+    , decltype(_impl_.viewoncemessagev2_){nullptr}
+  };
+  _impl_.conversation_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.conversation_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Message::~Message() {
+  // @@protoc_insertion_point(destructor:proto.Message)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Message::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.conversation_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.senderkeydistributionmessage_;
+  if (this != internal_default_instance()) delete _impl_.imagemessage_;
+  if (this != internal_default_instance()) delete _impl_.contactmessage_;
+  if (this != internal_default_instance()) delete _impl_.locationmessage_;
+  if (this != internal_default_instance()) delete _impl_.extendedtextmessage_;
+  if (this != internal_default_instance()) delete _impl_.documentmessage_;
+  if (this != internal_default_instance()) delete _impl_.audiomessage_;
+  if (this != internal_default_instance()) delete _impl_.videomessage_;
+  if (this != internal_default_instance()) delete _impl_.call_;
+  if (this != internal_default_instance()) delete _impl_.chat_;
+  if (this != internal_default_instance()) delete _impl_.protocolmessage_;
+  if (this != internal_default_instance()) delete _impl_.contactsarraymessage_;
+  if (this != internal_default_instance()) delete _impl_.highlystructuredmessage_;
+  if (this != internal_default_instance()) delete _impl_.fastratchetkeysenderkeydistributionmessage_;
+  if (this != internal_default_instance()) delete _impl_.sendpaymentmessage_;
+  if (this != internal_default_instance()) delete _impl_.livelocationmessage_;
+  if (this != internal_default_instance()) delete _impl_.requestpaymentmessage_;
+  if (this != internal_default_instance()) delete _impl_.declinepaymentrequestmessage_;
+  if (this != internal_default_instance()) delete _impl_.cancelpaymentrequestmessage_;
+  if (this != internal_default_instance()) delete _impl_.templatemessage_;
+  if (this != internal_default_instance()) delete _impl_.stickermessage_;
+  if (this != internal_default_instance()) delete _impl_.groupinvitemessage_;
+  if (this != internal_default_instance()) delete _impl_.templatebuttonreplymessage_;
+  if (this != internal_default_instance()) delete _impl_.productmessage_;
+  if (this != internal_default_instance()) delete _impl_.devicesentmessage_;
+  if (this != internal_default_instance()) delete _impl_.messagecontextinfo_;
+  if (this != internal_default_instance()) delete _impl_.listmessage_;
+  if (this != internal_default_instance()) delete _impl_.viewoncemessage_;
+  if (this != internal_default_instance()) delete _impl_.ordermessage_;
+  if (this != internal_default_instance()) delete _impl_.listresponsemessage_;
+  if (this != internal_default_instance()) delete _impl_.ephemeralmessage_;
+  if (this != internal_default_instance()) delete _impl_.invoicemessage_;
+  if (this != internal_default_instance()) delete _impl_.buttonsmessage_;
+  if (this != internal_default_instance()) delete _impl_.buttonsresponsemessage_;
+  if (this != internal_default_instance()) delete _impl_.paymentinvitemessage_;
+  if (this != internal_default_instance()) delete _impl_.interactivemessage_;
+  if (this != internal_default_instance()) delete _impl_.reactionmessage_;
+  if (this != internal_default_instance()) delete _impl_.stickersyncrmrmessage_;
+  if (this != internal_default_instance()) delete _impl_.interactiveresponsemessage_;
+  if (this != internal_default_instance()) delete _impl_.pollcreationmessage_;
+  if (this != internal_default_instance()) delete _impl_.pollupdatemessage_;
+  if (this != internal_default_instance()) delete _impl_.keepinchatmessage_;
+  if (this != internal_default_instance()) delete _impl_.documentwithcaptionmessage_;
+  if (this != internal_default_instance()) delete _impl_.requestphonenumbermessage_;
+  if (this != internal_default_instance()) delete _impl_.viewoncemessagev2_;
+}
+
+void Message::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Message)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.conversation_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.senderkeydistributionmessage_ != nullptr);
+      _impl_.senderkeydistributionmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.imagemessage_ != nullptr);
+      _impl_.imagemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.contactmessage_ != nullptr);
+      _impl_.contactmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.locationmessage_ != nullptr);
+      _impl_.locationmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.extendedtextmessage_ != nullptr);
+      _impl_.extendedtextmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.documentmessage_ != nullptr);
+      _impl_.documentmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.audiomessage_ != nullptr);
+      _impl_.audiomessage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      GOOGLE_DCHECK(_impl_.videomessage_ != nullptr);
+      _impl_.videomessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      GOOGLE_DCHECK(_impl_.call_ != nullptr);
+      _impl_.call_->Clear();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.chat_ != nullptr);
+      _impl_.chat_->Clear();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      GOOGLE_DCHECK(_impl_.protocolmessage_ != nullptr);
+      _impl_.protocolmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.contactsarraymessage_ != nullptr);
+      _impl_.contactsarraymessage_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.highlystructuredmessage_ != nullptr);
+      _impl_.highlystructuredmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00004000u) {
+      GOOGLE_DCHECK(_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr);
+      _impl_.fastratchetkeysenderkeydistributionmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00008000u) {
+      GOOGLE_DCHECK(_impl_.sendpaymentmessage_ != nullptr);
+      _impl_.sendpaymentmessage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      GOOGLE_DCHECK(_impl_.livelocationmessage_ != nullptr);
+      _impl_.livelocationmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00020000u) {
+      GOOGLE_DCHECK(_impl_.requestpaymentmessage_ != nullptr);
+      _impl_.requestpaymentmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00040000u) {
+      GOOGLE_DCHECK(_impl_.declinepaymentrequestmessage_ != nullptr);
+      _impl_.declinepaymentrequestmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00080000u) {
+      GOOGLE_DCHECK(_impl_.cancelpaymentrequestmessage_ != nullptr);
+      _impl_.cancelpaymentrequestmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00100000u) {
+      GOOGLE_DCHECK(_impl_.templatemessage_ != nullptr);
+      _impl_.templatemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00200000u) {
+      GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr);
+      _impl_.stickermessage_->Clear();
+    }
+    if (cached_has_bits & 0x00400000u) {
+      GOOGLE_DCHECK(_impl_.groupinvitemessage_ != nullptr);
+      _impl_.groupinvitemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00800000u) {
+      GOOGLE_DCHECK(_impl_.templatebuttonreplymessage_ != nullptr);
+      _impl_.templatebuttonreplymessage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0xff000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      GOOGLE_DCHECK(_impl_.productmessage_ != nullptr);
+      _impl_.productmessage_->Clear();
+    }
+    if (cached_has_bits & 0x02000000u) {
+      GOOGLE_DCHECK(_impl_.devicesentmessage_ != nullptr);
+      _impl_.devicesentmessage_->Clear();
+    }
+    if (cached_has_bits & 0x04000000u) {
+      GOOGLE_DCHECK(_impl_.messagecontextinfo_ != nullptr);
+      _impl_.messagecontextinfo_->Clear();
+    }
+    if (cached_has_bits & 0x08000000u) {
+      GOOGLE_DCHECK(_impl_.listmessage_ != nullptr);
+      _impl_.listmessage_->Clear();
+    }
+    if (cached_has_bits & 0x10000000u) {
+      GOOGLE_DCHECK(_impl_.viewoncemessage_ != nullptr);
+      _impl_.viewoncemessage_->Clear();
+    }
+    if (cached_has_bits & 0x20000000u) {
+      GOOGLE_DCHECK(_impl_.ordermessage_ != nullptr);
+      _impl_.ordermessage_->Clear();
+    }
+    if (cached_has_bits & 0x40000000u) {
+      GOOGLE_DCHECK(_impl_.listresponsemessage_ != nullptr);
+      _impl_.listresponsemessage_->Clear();
+    }
+    if (cached_has_bits & 0x80000000u) {
+      GOOGLE_DCHECK(_impl_.ephemeralmessage_ != nullptr);
+      _impl_.ephemeralmessage_->Clear();
+    }
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.invoicemessage_ != nullptr);
+      _impl_.invoicemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.buttonsmessage_ != nullptr);
+      _impl_.buttonsmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.buttonsresponsemessage_ != nullptr);
+      _impl_.buttonsresponsemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.paymentinvitemessage_ != nullptr);
+      _impl_.paymentinvitemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.interactivemessage_ != nullptr);
+      _impl_.interactivemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.reactionmessage_ != nullptr);
+      _impl_.reactionmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.stickersyncrmrmessage_ != nullptr);
+      _impl_.stickersyncrmrmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.interactiveresponsemessage_ != nullptr);
+      _impl_.interactiveresponsemessage_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      GOOGLE_DCHECK(_impl_.pollcreationmessage_ != nullptr);
+      _impl_.pollcreationmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      GOOGLE_DCHECK(_impl_.pollupdatemessage_ != nullptr);
+      _impl_.pollupdatemessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.keepinchatmessage_ != nullptr);
+      _impl_.keepinchatmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      GOOGLE_DCHECK(_impl_.documentwithcaptionmessage_ != nullptr);
+      _impl_.documentwithcaptionmessage_->Clear();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.requestphonenumbermessage_ != nullptr);
+      _impl_.requestphonenumbermessage_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.viewoncemessagev2_ != nullptr);
+      _impl_.viewoncemessagev2_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Message::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string conversation = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_conversation();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Message.conversation");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_senderkeydistributionmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ImageMessage imageMessage = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ContactMessage contactMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contactmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.LocationMessage locationMessage = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extendedtextmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.DocumentMessage documentMessage = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.AudioMessage audioMessage = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_audiomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.VideoMessage videoMessage = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.Call call = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_call(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.Chat chat = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_chat(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ProtocolMessage protocolMessage = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_protocolmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contactsarraymessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fastratchetkeysenderkeydistributionmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_sendpaymentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr = ctx->ParseMessage(_internal_mutable_livelocationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestpaymentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_declinepaymentrequestmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_cancelpaymentrequestmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.TemplateMessage templateMessage = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
+          ptr = ctx->ParseMessage(_internal_mutable_templatemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.StickerMessage stickerMessage = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_groupinvitemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_templatebuttonreplymessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ProductMessage productMessage = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
+          ptr = ctx->ParseMessage(_internal_mutable_productmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 250)) {
+          ptr = ctx->ParseMessage(_internal_mutable_devicesentmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MessageContextInfo messageContextInfo = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_messagecontextinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListMessage listMessage = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_listmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
+      case 37:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_viewoncemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.OrderMessage orderMessage = 38;
+      case 38:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_ordermessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ListResponseMessage listResponseMessage = 39;
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_listresponsemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
+      case 40:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_ephemeralmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InvoiceMessage invoiceMessage = 41;
+      case 41:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_invoicemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsMessage buttonsMessage = 42;
+      case 42:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_buttonsmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
+      case 43:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_buttonsresponsemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
+      case 44:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_paymentinvitemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InteractiveMessage interactiveMessage = 45;
+      case 45:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interactivemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.ReactionMessage reactionMessage = 46;
+      case 46:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_reactionmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+      case 47:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_stickersyncrmrmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
+      case 48:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interactiveresponsemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
+      case 49:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
+      case 50:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
+      case 51:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keepinchatmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
+      case 53:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          ptr = ctx->ParseMessage(_internal_mutable_documentwithcaptionmessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+      case 54:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestphonenumbermessage(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
+      case 55:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_viewoncemessagev2(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Message::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Message)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string conversation = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_conversation().data(), static_cast<int>(this->_internal_conversation().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Message.conversation");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_conversation(), target);
+  }
+
+  // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::senderkeydistributionmessage(this),
+        _Internal::senderkeydistributionmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ImageMessage imageMessage = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::imagemessage(this),
+        _Internal::imagemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ContactMessage contactMessage = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::contactmessage(this),
+        _Internal::contactmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.LocationMessage locationMessage = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::locationmessage(this),
+        _Internal::locationmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::extendedtextmessage(this),
+        _Internal::extendedtextmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.DocumentMessage documentMessage = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::documentmessage(this),
+        _Internal::documentmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.AudioMessage audioMessage = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::audiomessage(this),
+        _Internal::audiomessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.VideoMessage videoMessage = 9;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::videomessage(this),
+        _Internal::videomessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.Call call = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(10, _Internal::call(this),
+        _Internal::call(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.Chat chat = 11;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(11, _Internal::chat(this),
+        _Internal::chat(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ProtocolMessage protocolMessage = 12;
+  if (cached_has_bits & 0x00000800u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(12, _Internal::protocolmessage(this),
+        _Internal::protocolmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(13, _Internal::contactsarraymessage(this),
+        _Internal::contactsarraymessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(14, _Internal::highlystructuredmessage(this),
+        _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+  if (cached_has_bits & 0x00004000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, _Internal::fastratchetkeysenderkeydistributionmessage(this),
+        _Internal::fastratchetkeysenderkeydistributionmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
+  if (cached_has_bits & 0x00008000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(16, _Internal::sendpaymentmessage(this),
+        _Internal::sendpaymentmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
+  if (cached_has_bits & 0x00010000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(18, _Internal::livelocationmessage(this),
+        _Internal::livelocationmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
+  if (cached_has_bits & 0x00020000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(22, _Internal::requestpaymentmessage(this),
+        _Internal::requestpaymentmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+  if (cached_has_bits & 0x00040000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(23, _Internal::declinepaymentrequestmessage(this),
+        _Internal::declinepaymentrequestmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+  if (cached_has_bits & 0x00080000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(24, _Internal::cancelpaymentrequestmessage(this),
+        _Internal::cancelpaymentrequestmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.TemplateMessage templateMessage = 25;
+  if (cached_has_bits & 0x00100000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(25, _Internal::templatemessage(this),
+        _Internal::templatemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.StickerMessage stickerMessage = 26;
+  if (cached_has_bits & 0x00200000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(26, _Internal::stickermessage(this),
+        _Internal::stickermessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
+  if (cached_has_bits & 0x00400000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(28, _Internal::groupinvitemessage(this),
+        _Internal::groupinvitemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+  if (cached_has_bits & 0x00800000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(29, _Internal::templatebuttonreplymessage(this),
+        _Internal::templatebuttonreplymessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ProductMessage productMessage = 30;
+  if (cached_has_bits & 0x01000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(30, _Internal::productmessage(this),
+        _Internal::productmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
+  if (cached_has_bits & 0x02000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(31, _Internal::devicesentmessage(this),
+        _Internal::devicesentmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MessageContextInfo messageContextInfo = 35;
+  if (cached_has_bits & 0x04000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(35, _Internal::messagecontextinfo(this),
+        _Internal::messagecontextinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ListMessage listMessage = 36;
+  if (cached_has_bits & 0x08000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(36, _Internal::listmessage(this),
+        _Internal::listmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
+  if (cached_has_bits & 0x10000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(37, _Internal::viewoncemessage(this),
+        _Internal::viewoncemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.OrderMessage orderMessage = 38;
+  if (cached_has_bits & 0x20000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(38, _Internal::ordermessage(this),
+        _Internal::ordermessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ListResponseMessage listResponseMessage = 39;
+  if (cached_has_bits & 0x40000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(39, _Internal::listresponsemessage(this),
+        _Internal::listresponsemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
+  if (cached_has_bits & 0x80000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(40, _Internal::ephemeralmessage(this),
+        _Internal::ephemeralmessage(this).GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional .proto.Message.InvoiceMessage invoiceMessage = 41;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(41, _Internal::invoicemessage(this),
+        _Internal::invoicemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ButtonsMessage buttonsMessage = 42;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(42, _Internal::buttonsmessage(this),
+        _Internal::buttonsmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(43, _Internal::buttonsresponsemessage(this),
+        _Internal::buttonsresponsemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(44, _Internal::paymentinvitemessage(this),
+        _Internal::paymentinvitemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.InteractiveMessage interactiveMessage = 45;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(45, _Internal::interactivemessage(this),
+        _Internal::interactivemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.ReactionMessage reactionMessage = 46;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(46, _Internal::reactionmessage(this),
+        _Internal::reactionmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(47, _Internal::stickersyncrmrmessage(this),
+        _Internal::stickersyncrmrmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(48, _Internal::interactiveresponsemessage(this),
+        _Internal::interactiveresponsemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(49, _Internal::pollcreationmessage(this),
+        _Internal::pollcreationmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
+  if (cached_has_bits & 0x00000200u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(50, _Internal::pollupdatemessage(this),
+        _Internal::pollupdatemessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(51, _Internal::keepinchatmessage(this),
+        _Internal::keepinchatmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
+  if (cached_has_bits & 0x00000800u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(53, _Internal::documentwithcaptionmessage(this),
+        _Internal::documentwithcaptionmessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(54, _Internal::requestphonenumbermessage(this),
+        _Internal::requestphonenumbermessage(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(55, _Internal::viewoncemessagev2(this),
+        _Internal::viewoncemessagev2(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Message)
+  return target;
+}
+
+size_t Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Message)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string conversation = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_conversation());
+    }
+
+    // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.senderkeydistributionmessage_);
+    }
+
+    // optional .proto.Message.ImageMessage imageMessage = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.imagemessage_);
+    }
+
+    // optional .proto.Message.ContactMessage contactMessage = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contactmessage_);
+    }
+
+    // optional .proto.Message.LocationMessage locationMessage = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.locationmessage_);
+    }
+
+    // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.extendedtextmessage_);
+    }
+
+    // optional .proto.Message.DocumentMessage documentMessage = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.documentmessage_);
+    }
+
+    // optional .proto.Message.AudioMessage audioMessage = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.audiomessage_);
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional .proto.Message.VideoMessage videoMessage = 9;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.videomessage_);
+    }
+
+    // optional .proto.Message.Call call = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.call_);
+    }
+
+    // optional .proto.Message.Chat chat = 11;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.chat_);
+    }
+
+    // optional .proto.Message.ProtocolMessage protocolMessage = 12;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.protocolmessage_);
+    }
+
+    // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contactsarraymessage_);
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.highlystructuredmessage_);
+    }
+
+    // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.fastratchetkeysenderkeydistributionmessage_);
+    }
+
+    // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.sendpaymentmessage_);
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.livelocationmessage_);
+    }
+
+    // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestpaymentmessage_);
+    }
+
+    // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.declinepaymentrequestmessage_);
+    }
+
+    // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.cancelpaymentrequestmessage_);
+    }
+
+    // optional .proto.Message.TemplateMessage templateMessage = 25;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.templatemessage_);
+    }
+
+    // optional .proto.Message.StickerMessage stickerMessage = 26;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.stickermessage_);
+    }
+
+    // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.groupinvitemessage_);
+    }
+
+    // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.templatebuttonreplymessage_);
+    }
+
+  }
+  if (cached_has_bits & 0xff000000u) {
+    // optional .proto.Message.ProductMessage productMessage = 30;
+    if (cached_has_bits & 0x01000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.productmessage_);
+    }
+
+    // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
+    if (cached_has_bits & 0x02000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.devicesentmessage_);
+    }
+
+    // optional .proto.MessageContextInfo messageContextInfo = 35;
+    if (cached_has_bits & 0x04000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.messagecontextinfo_);
+    }
+
+    // optional .proto.Message.ListMessage listMessage = 36;
+    if (cached_has_bits & 0x08000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.listmessage_);
+    }
+
+    // optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
+    if (cached_has_bits & 0x10000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.viewoncemessage_);
+    }
+
+    // optional .proto.Message.OrderMessage orderMessage = 38;
+    if (cached_has_bits & 0x20000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.ordermessage_);
+    }
+
+    // optional .proto.Message.ListResponseMessage listResponseMessage = 39;
+    if (cached_has_bits & 0x40000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.listresponsemessage_);
+    }
+
+    // optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
+    if (cached_has_bits & 0x80000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.ephemeralmessage_);
+    }
+
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.Message.InvoiceMessage invoiceMessage = 41;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.invoicemessage_);
+    }
+
+    // optional .proto.Message.ButtonsMessage buttonsMessage = 42;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.buttonsmessage_);
+    }
+
+    // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.buttonsresponsemessage_);
+    }
+
+    // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.paymentinvitemessage_);
+    }
+
+    // optional .proto.Message.InteractiveMessage interactiveMessage = 45;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactivemessage_);
+    }
+
+    // optional .proto.Message.ReactionMessage reactionMessage = 46;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.reactionmessage_);
+    }
+
+    // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.stickersyncrmrmessage_);
+    }
+
+    // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.interactiveresponsemessage_);
+    }
+
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    // optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pollcreationmessage_);
+    }
+
+    // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pollupdatemessage_);
+    }
+
+    // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keepinchatmessage_);
+    }
+
+    // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.documentwithcaptionmessage_);
+    }
+
+    // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestphonenumbermessage_);
+    }
+
+    // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.viewoncemessagev2_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Message::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message::GetClassData() const { return &_class_data_; }
+
+
+void Message::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Message*>(&to_msg);
+  auto& from = static_cast<const Message&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_conversation(from._internal_conversation());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_senderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom(
+          from._internal_senderkeydistributionmessage());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom(
+          from._internal_imagemessage());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_contactmessage()->::proto::Message_ContactMessage::MergeFrom(
+          from._internal_contactmessage());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom(
+          from._internal_locationmessage());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_extendedtextmessage()->::proto::Message_ExtendedTextMessage::MergeFrom(
+          from._internal_extendedtextmessage());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom(
+          from._internal_documentmessage());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_audiomessage()->::proto::Message_AudioMessage::MergeFrom(
+          from._internal_audiomessage());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom(
+          from._internal_videomessage());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_mutable_call()->::proto::Message_Call::MergeFrom(
+          from._internal_call());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_chat()->::proto::Message_Chat::MergeFrom(
+          from._internal_chat());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_mutable_protocolmessage()->::proto::Message_ProtocolMessage::MergeFrom(
+          from._internal_protocolmessage());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_contactsarraymessage()->::proto::Message_ContactsArrayMessage::MergeFrom(
+          from._internal_contactsarraymessage());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_highlystructuredmessage());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_internal_mutable_fastratchetkeysenderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom(
+          from._internal_fastratchetkeysenderkeydistributionmessage());
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_internal_mutable_sendpaymentmessage()->::proto::Message_SendPaymentMessage::MergeFrom(
+          from._internal_sendpaymentmessage());
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_internal_mutable_livelocationmessage()->::proto::Message_LiveLocationMessage::MergeFrom(
+          from._internal_livelocationmessage());
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_internal_mutable_requestpaymentmessage()->::proto::Message_RequestPaymentMessage::MergeFrom(
+          from._internal_requestpaymentmessage());
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_internal_mutable_declinepaymentrequestmessage()->::proto::Message_DeclinePaymentRequestMessage::MergeFrom(
+          from._internal_declinepaymentrequestmessage());
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_internal_mutable_cancelpaymentrequestmessage()->::proto::Message_CancelPaymentRequestMessage::MergeFrom(
+          from._internal_cancelpaymentrequestmessage());
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_internal_mutable_templatemessage()->::proto::Message_TemplateMessage::MergeFrom(
+          from._internal_templatemessage());
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom(
+          from._internal_stickermessage());
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_internal_mutable_groupinvitemessage()->::proto::Message_GroupInviteMessage::MergeFrom(
+          from._internal_groupinvitemessage());
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_internal_mutable_templatebuttonreplymessage()->::proto::Message_TemplateButtonReplyMessage::MergeFrom(
+          from._internal_templatebuttonreplymessage());
+    }
+  }
+  if (cached_has_bits & 0xff000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      _this->_internal_mutable_productmessage()->::proto::Message_ProductMessage::MergeFrom(
+          from._internal_productmessage());
+    }
+    if (cached_has_bits & 0x02000000u) {
+      _this->_internal_mutable_devicesentmessage()->::proto::Message_DeviceSentMessage::MergeFrom(
+          from._internal_devicesentmessage());
+    }
+    if (cached_has_bits & 0x04000000u) {
+      _this->_internal_mutable_messagecontextinfo()->::proto::MessageContextInfo::MergeFrom(
+          from._internal_messagecontextinfo());
+    }
+    if (cached_has_bits & 0x08000000u) {
+      _this->_internal_mutable_listmessage()->::proto::Message_ListMessage::MergeFrom(
+          from._internal_listmessage());
+    }
+    if (cached_has_bits & 0x10000000u) {
+      _this->_internal_mutable_viewoncemessage()->::proto::Message_FutureProofMessage::MergeFrom(
+          from._internal_viewoncemessage());
+    }
+    if (cached_has_bits & 0x20000000u) {
+      _this->_internal_mutable_ordermessage()->::proto::Message_OrderMessage::MergeFrom(
+          from._internal_ordermessage());
+    }
+    if (cached_has_bits & 0x40000000u) {
+      _this->_internal_mutable_listresponsemessage()->::proto::Message_ListResponseMessage::MergeFrom(
+          from._internal_listresponsemessage());
+    }
+    if (cached_has_bits & 0x80000000u) {
+      _this->_internal_mutable_ephemeralmessage()->::proto::Message_FutureProofMessage::MergeFrom(
+          from._internal_ephemeralmessage());
+    }
+  }
+  cached_has_bits = from._impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_invoicemessage()->::proto::Message_InvoiceMessage::MergeFrom(
+          from._internal_invoicemessage());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_buttonsmessage()->::proto::Message_ButtonsMessage::MergeFrom(
+          from._internal_buttonsmessage());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_buttonsresponsemessage()->::proto::Message_ButtonsResponseMessage::MergeFrom(
+          from._internal_buttonsresponsemessage());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_paymentinvitemessage()->::proto::Message_PaymentInviteMessage::MergeFrom(
+          from._internal_paymentinvitemessage());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_interactivemessage()->::proto::Message_InteractiveMessage::MergeFrom(
+          from._internal_interactivemessage());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_reactionmessage()->::proto::Message_ReactionMessage::MergeFrom(
+          from._internal_reactionmessage());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_stickersyncrmrmessage()->::proto::Message_StickerSyncRMRMessage::MergeFrom(
+          from._internal_stickersyncrmrmessage());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_interactiveresponsemessage()->::proto::Message_InteractiveResponseMessage::MergeFrom(
+          from._internal_interactiveresponsemessage());
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_pollcreationmessage()->::proto::Message_PollCreationMessage::MergeFrom(
+          from._internal_pollcreationmessage());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_mutable_pollupdatemessage()->::proto::Message_PollUpdateMessage::MergeFrom(
+          from._internal_pollupdatemessage());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_keepinchatmessage()->::proto::Message_KeepInChatMessage::MergeFrom(
+          from._internal_keepinchatmessage());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_mutable_documentwithcaptionmessage()->::proto::Message_FutureProofMessage::MergeFrom(
+          from._internal_documentwithcaptionmessage());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_requestphonenumbermessage()->::proto::Message_RequestPhoneNumberMessage::MergeFrom(
+          from._internal_requestphonenumbermessage());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_viewoncemessagev2()->::proto::Message_FutureProofMessage::MergeFrom(
+          from._internal_viewoncemessagev2());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Message::CopyFrom(const Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message::IsInitialized() const {
+  return true;
+}
+
+void Message::InternalSwap(Message* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.conversation_, lhs_arena,
+      &other->_impl_.conversation_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Message, _impl_.viewoncemessagev2_)
+      + sizeof(Message::_impl_.viewoncemessagev2_)
+      - PROTOBUF_FIELD_OFFSET(Message, _impl_.senderkeydistributionmessage_)>(
+          reinterpret_cast<char*>(&_impl_.senderkeydistributionmessage_),
+          reinterpret_cast<char*>(&other->_impl_.senderkeydistributionmessage_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Message::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[137]);
+}
+
+// ===================================================================
+
+class MessageContextInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MessageContextInfo>()._impl_._has_bits_);
+  static const ::proto::DeviceListMetadata& devicelistmetadata(const MessageContextInfo* msg);
+  static void set_has_devicelistmetadata(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_devicelistmetadataversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_messagesecret(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_paddingbytes(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::DeviceListMetadata&
+MessageContextInfo::_Internal::devicelistmetadata(const MessageContextInfo* msg) {
+  return *msg->_impl_.devicelistmetadata_;
+}
+MessageContextInfo::MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MessageContextInfo)
+}
+MessageContextInfo::MessageContextInfo(const MessageContextInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MessageContextInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.paddingbytes_){}
+    , decltype(_impl_.devicelistmetadata_){nullptr}
+    , decltype(_impl_.devicelistmetadataversion_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_messagesecret()) {
+    _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.paddingbytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_paddingbytes()) {
+    _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_devicelistmetadata()) {
+    _this->_impl_.devicelistmetadata_ = new ::proto::DeviceListMetadata(*from._impl_.devicelistmetadata_);
+  }
+  _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_;
+  // @@protoc_insertion_point(copy_constructor:proto.MessageContextInfo)
+}
+
+inline void MessageContextInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.paddingbytes_){}
+    , decltype(_impl_.devicelistmetadata_){nullptr}
+    , decltype(_impl_.devicelistmetadataversion_){0}
+  };
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.paddingbytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MessageContextInfo::~MessageContextInfo() {
+  // @@protoc_insertion_point(destructor:proto.MessageContextInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MessageContextInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.messagesecret_.Destroy();
+  _impl_.paddingbytes_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.devicelistmetadata_;
+}
+
+void MessageContextInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MessageContextInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MessageContextInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.messagesecret_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.paddingbytes_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.devicelistmetadata_ != nullptr);
+      _impl_.devicelistmetadata_->Clear();
+    }
+  }
+  _impl_.devicelistmetadataversion_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MessageContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.DeviceListMetadata deviceListMetadata = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_devicelistmetadata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 deviceListMetadataVersion = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_devicelistmetadataversion(&has_bits);
+          _impl_.devicelistmetadataversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes messageSecret = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_messagesecret();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes paddingBytes = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_paddingbytes();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MessageContextInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MessageContextInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.DeviceListMetadata deviceListMetadata = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::devicelistmetadata(this),
+        _Internal::devicelistmetadata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int32 deviceListMetadataVersion = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_devicelistmetadataversion(), target);
+  }
+
+  // optional bytes messageSecret = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_messagesecret(), target);
+  }
+
+  // optional bytes paddingBytes = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_paddingbytes(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MessageContextInfo)
+  return target;
+}
+
+size_t MessageContextInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MessageContextInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes messageSecret = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_messagesecret());
+    }
+
+    // optional bytes paddingBytes = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_paddingbytes());
+    }
+
+    // optional .proto.DeviceListMetadata deviceListMetadata = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.devicelistmetadata_);
+    }
+
+    // optional int32 deviceListMetadataVersion = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_devicelistmetadataversion());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageContextInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MessageContextInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageContextInfo::GetClassData() const { return &_class_data_; }
+
+
+void MessageContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MessageContextInfo*>(&to_msg);
+  auto& from = static_cast<const MessageContextInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageContextInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_messagesecret(from._internal_messagesecret());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_paddingbytes(from._internal_paddingbytes());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_devicelistmetadata()->::proto::DeviceListMetadata::MergeFrom(
+          from._internal_devicelistmetadata());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MessageContextInfo::CopyFrom(const MessageContextInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageContextInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MessageContextInfo::IsInitialized() const {
+  return true;
+}
+
+void MessageContextInfo::InternalSwap(MessageContextInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.messagesecret_, lhs_arena,
+      &other->_impl_.messagesecret_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.paddingbytes_, lhs_arena,
+      &other->_impl_.paddingbytes_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadataversion_)
+      + sizeof(MessageContextInfo::_impl_.devicelistmetadataversion_)
+      - PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadata_)>(
+          reinterpret_cast<char*>(&_impl_.devicelistmetadata_),
+          reinterpret_cast<char*>(&other->_impl_.devicelistmetadata_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MessageContextInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[138]);
+}
+
+// ===================================================================
+
+class MessageKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MessageKey>()._impl_._has_bits_);
+  static void set_has_remotejid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_fromme(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_participant(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+MessageKey::MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MessageKey)
+}
+MessageKey::MessageKey(const MessageKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MessageKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.remotejid_){}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.fromme_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.remotejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_remotejid()) {
+    _this->_impl_.remotejid_.Set(from._internal_remotejid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_participant()) {
+    _this->_impl_.participant_.Set(from._internal_participant(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.fromme_ = from._impl_.fromme_;
+  // @@protoc_insertion_point(copy_constructor:proto.MessageKey)
+}
+
+inline void MessageKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.remotejid_){}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.fromme_){false}
+  };
+  _impl_.remotejid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MessageKey::~MessageKey() {
+  // @@protoc_insertion_point(destructor:proto.MessageKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MessageKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.remotejid_.Destroy();
+  _impl_.id_.Destroy();
+  _impl_.participant_.Destroy();
+}
+
+void MessageKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MessageKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MessageKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.remotejid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.participant_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.fromme_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string remoteJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_remotejid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MessageKey.remoteJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool fromMe = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_fromme(&has_bits);
+          _impl_.fromme_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string id = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MessageKey.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string participant = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_participant();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MessageKey.participant");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MessageKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MessageKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string remoteJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_remotejid().data(), static_cast<int>(this->_internal_remotejid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MessageKey.remoteJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_remotejid(), target);
+  }
+
+  // optional bool fromMe = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_fromme(), target);
+  }
+
+  // optional string id = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MessageKey.id");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_id(), target);
+  }
+
+  // optional string participant = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_participant().data(), static_cast<int>(this->_internal_participant().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MessageKey.participant");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_participant(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MessageKey)
+  return target;
+}
+
+size_t MessageKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MessageKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string remoteJid = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_remotejid());
+    }
+
+    // optional string id = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional string participant = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_participant());
+    }
+
+    // optional bool fromMe = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MessageKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageKey::GetClassData() const { return &_class_data_; }
+
+
+void MessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MessageKey*>(&to_msg);
+  auto& from = static_cast<const MessageKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_remotejid(from._internal_remotejid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_participant(from._internal_participant());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.fromme_ = from._impl_.fromme_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MessageKey::CopyFrom(const MessageKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MessageKey::IsInitialized() const {
+  return true;
+}
+
+void MessageKey::InternalSwap(MessageKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.remotejid_, lhs_arena,
+      &other->_impl_.remotejid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.participant_, lhs_arena,
+      &other->_impl_.participant_, rhs_arena
+  );
+  swap(_impl_.fromme_, other->_impl_.fromme_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MessageKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[139]);
+}
+
+// ===================================================================
+
+class Money::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Money>()._impl_._has_bits_);
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_offset(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_currencycode(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Money::Money(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Money)
+}
+Money::Money(const Money& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Money* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.value_){}
+    , decltype(_impl_.offset_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_currencycode()) {
+    _this->_impl_.currencycode_.Set(from._internal_currencycode(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.value_, &from._impl_.value_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.offset_) -
+    reinterpret_cast<char*>(&_impl_.value_)) + sizeof(_impl_.offset_));
+  // @@protoc_insertion_point(copy_constructor:proto.Money)
+}
+
+inline void Money::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currencycode_){}
+    , decltype(_impl_.value_){int64_t{0}}
+    , decltype(_impl_.offset_){0u}
+  };
+  _impl_.currencycode_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Money::~Money() {
+  // @@protoc_insertion_point(destructor:proto.Money)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Money::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.currencycode_.Destroy();
+}
+
+void Money::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Money::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Money)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.currencycode_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.value_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.offset_) -
+        reinterpret_cast<char*>(&_impl_.value_)) + sizeof(_impl_.offset_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Money::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int64 value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_value(&has_bits);
+          _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 offset = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_offset(&has_bits);
+          _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string currencyCode = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_currencycode();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Money.currencyCode");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Money::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Money)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 value = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target);
+  }
+
+  // optional uint32 offset = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_offset(), target);
+  }
+
+  // optional string currencyCode = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_currencycode().data(), static_cast<int>(this->_internal_currencycode().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Money.currencyCode");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_currencycode(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Money)
+  return target;
+}
+
+size_t Money::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Money)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string currencyCode = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_currencycode());
+    }
+
+    // optional int64 value = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_value());
+    }
+
+    // optional uint32 offset = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_offset());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Money::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Money::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Money::GetClassData() const { return &_class_data_; }
+
+
+void Money::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Money*>(&to_msg);
+  auto& from = static_cast<const Money&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Money)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_currencycode(from._internal_currencycode());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.value_ = from._impl_.value_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.offset_ = from._impl_.offset_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Money::CopyFrom(const Money& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Money)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Money::IsInitialized() const {
+  return true;
+}
+
+void Money::InternalSwap(Money* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.currencycode_, lhs_arena,
+      &other->_impl_.currencycode_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Money, _impl_.offset_)
+      + sizeof(Money::_impl_.offset_)
+      - PROTOBUF_FIELD_OFFSET(Money, _impl_.value_)>(
+          reinterpret_cast<char*>(&_impl_.value_),
+          reinterpret_cast<char*>(&other->_impl_.value_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Money::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[140]);
+}
+
+// ===================================================================
+
+class MsgOpaqueData_PollOption::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MsgOpaqueData_PollOption>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData.PollOption)
+}
+MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MsgOpaqueData_PollOption* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData.PollOption)
+}
+
+inline void MsgOpaqueData_PollOption::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MsgOpaqueData_PollOption::~MsgOpaqueData_PollOption() {
+  // @@protoc_insertion_point(destructor:proto.MsgOpaqueData.PollOption)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MsgOpaqueData_PollOption::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void MsgOpaqueData_PollOption::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MsgOpaqueData_PollOption::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData.PollOption)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MsgOpaqueData_PollOption::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.PollOption.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MsgOpaqueData_PollOption::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData.PollOption)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.PollOption.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MsgOpaqueData.PollOption)
+  return target;
+}
+
+size_t MsgOpaqueData_PollOption::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData.PollOption)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string name = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData_PollOption::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MsgOpaqueData_PollOption::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData_PollOption::GetClassData() const { return &_class_data_; }
+
+
+void MsgOpaqueData_PollOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MsgOpaqueData_PollOption*>(&to_msg);
+  auto& from = static_cast<const MsgOpaqueData_PollOption&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData.PollOption)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_name()) {
+    _this->_internal_set_name(from._internal_name());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MsgOpaqueData_PollOption::CopyFrom(const MsgOpaqueData_PollOption& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData.PollOption)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MsgOpaqueData_PollOption::IsInitialized() const {
+  return true;
+}
+
+void MsgOpaqueData_PollOption::InternalSwap(MsgOpaqueData_PollOption* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData_PollOption::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[141]);
+}
+
+// ===================================================================
+
+class MsgOpaqueData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MsgOpaqueData>()._impl_._has_bits_);
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_caption(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_lng(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_islive(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_lat(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_paymentamount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_paymentnotemsgbody(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_canonicalurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_matchedtext(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_title(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_futureproofbuffer(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_clienturl(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_loc(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_pollname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_pollselectableoptionscount(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_messagesecret(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_sendertimestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_pollupdateparentkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static const ::proto::PollEncValue& encpollvote(const MsgOpaqueData* msg);
+  static void set_has_encpollvote(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+};
+
+const ::proto::PollEncValue&
+MsgOpaqueData::_Internal::encpollvote(const MsgOpaqueData* msg) {
+  return *msg->_impl_.encpollvote_;
+}
+MsgOpaqueData::MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData)
+}
+MsgOpaqueData::MsgOpaqueData(const MsgOpaqueData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MsgOpaqueData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.polloptions_){from._impl_.polloptions_}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.paymentnotemsgbody_){}
+    , decltype(_impl_.canonicalurl_){}
+    , decltype(_impl_.matchedtext_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.futureproofbuffer_){}
+    , decltype(_impl_.clienturl_){}
+    , decltype(_impl_.loc_){}
+    , decltype(_impl_.pollname_){}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.pollupdateparentkey_){}
+    , decltype(_impl_.encpollvote_){nullptr}
+    , decltype(_impl_.lng_){}
+    , decltype(_impl_.lat_){}
+    , decltype(_impl_.islive_){}
+    , decltype(_impl_.paymentamount1000_){}
+    , decltype(_impl_.sendertimestampms_){}
+    , decltype(_impl_.pollselectableoptionscount_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_caption()) {
+    _this->_impl_.caption_.Set(from._internal_caption(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.paymentnotemsgbody_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_paymentnotemsgbody()) {
+    _this->_impl_.paymentnotemsgbody_.Set(from._internal_paymentnotemsgbody(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.canonicalurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_canonicalurl()) {
+    _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.matchedtext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_matchedtext()) {
+    _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_title()) {
+    _this->_impl_.title_.Set(from._internal_title(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.futureproofbuffer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_futureproofbuffer()) {
+    _this->_impl_.futureproofbuffer_.Set(from._internal_futureproofbuffer(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.clienturl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.clienturl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_clienturl()) {
+    _this->_impl_.clienturl_.Set(from._internal_clienturl(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.loc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.loc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_loc()) {
+    _this->_impl_.loc_.Set(from._internal_loc(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pollname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pollname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pollname()) {
+    _this->_impl_.pollname_.Set(from._internal_pollname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_messagesecret()) {
+    _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pollupdateparentkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pollupdateparentkey()) {
+    _this->_impl_.pollupdateparentkey_.Set(from._internal_pollupdateparentkey(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_encpollvote()) {
+    _this->_impl_.encpollvote_ = new ::proto::PollEncValue(*from._impl_.encpollvote_);
+  }
+  ::memcpy(&_impl_.lng_, &from._impl_.lng_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.pollselectableoptionscount_) -
+    reinterpret_cast<char*>(&_impl_.lng_)) + sizeof(_impl_.pollselectableoptionscount_));
+  // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData)
+}
+
+inline void MsgOpaqueData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.polloptions_){arena}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.caption_){}
+    , decltype(_impl_.paymentnotemsgbody_){}
+    , decltype(_impl_.canonicalurl_){}
+    , decltype(_impl_.matchedtext_){}
+    , decltype(_impl_.title_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.futureproofbuffer_){}
+    , decltype(_impl_.clienturl_){}
+    , decltype(_impl_.loc_){}
+    , decltype(_impl_.pollname_){}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.pollupdateparentkey_){}
+    , decltype(_impl_.encpollvote_){nullptr}
+    , decltype(_impl_.lng_){0}
+    , decltype(_impl_.lat_){0}
+    , decltype(_impl_.islive_){false}
+    , decltype(_impl_.paymentamount1000_){0}
+    , decltype(_impl_.sendertimestampms_){int64_t{0}}
+    , decltype(_impl_.pollselectableoptionscount_){0u}
+  };
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.caption_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.paymentnotemsgbody_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.canonicalurl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.matchedtext_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.title_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.title_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.futureproofbuffer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.clienturl_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.clienturl_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.loc_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.loc_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pollname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pollname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pollupdateparentkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+MsgOpaqueData::~MsgOpaqueData() {
+  // @@protoc_insertion_point(destructor:proto.MsgOpaqueData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MsgOpaqueData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.polloptions_.~RepeatedPtrField();
+  _impl_.body_.Destroy();
+  _impl_.caption_.Destroy();
+  _impl_.paymentnotemsgbody_.Destroy();
+  _impl_.canonicalurl_.Destroy();
+  _impl_.matchedtext_.Destroy();
+  _impl_.title_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.futureproofbuffer_.Destroy();
+  _impl_.clienturl_.Destroy();
+  _impl_.loc_.Destroy();
+  _impl_.pollname_.Destroy();
+  _impl_.messagesecret_.Destroy();
+  _impl_.pollupdateparentkey_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.encpollvote_;
+}
+
+void MsgOpaqueData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MsgOpaqueData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.polloptions_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.body_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.caption_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.paymentnotemsgbody_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.canonicalurl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.matchedtext_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.title_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.futureproofbuffer_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00003f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _impl_.clienturl_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _impl_.loc_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _impl_.pollname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _impl_.messagesecret_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _impl_.pollupdateparentkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.encpollvote_ != nullptr);
+      _impl_.encpollvote_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000c000u) {
+    ::memset(&_impl_.lng_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.lat_) -
+        reinterpret_cast<char*>(&_impl_.lng_)) + sizeof(_impl_.lat_));
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    ::memset(&_impl_.islive_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.pollselectableoptionscount_) -
+        reinterpret_cast<char*>(&_impl_.islive_)) + sizeof(_impl_.pollselectableoptionscount_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MsgOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string body = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.body");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string caption = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_caption();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.caption");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double lng = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 41)) {
+          _Internal::set_has_lng(&has_bits);
+          _impl_.lng_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isLive = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_islive(&has_bits);
+          _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double lat = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
+          _Internal::set_has_lat(&has_bits);
+          _impl_.lat_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 paymentAmount1000 = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_paymentamount1000(&has_bits);
+          _impl_.paymentamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string paymentNoteMsgBody = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_paymentnotemsgbody();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.paymentNoteMsgBody");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string canonicalUrl = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          auto str = _internal_mutable_canonicalurl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.canonicalUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string matchedText = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_matchedtext();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.matchedText");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string title = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          auto str = _internal_mutable_title();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.title");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.description");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes futureproofBuffer = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          auto str = _internal_mutable_futureproofbuffer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string clientUrl = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          auto str = _internal_mutable_clienturl();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.clientUrl");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string loc = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          auto str = _internal_mutable_loc();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.loc");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pollName = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          auto str = _internal_mutable_pollname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_polloptions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<146>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 pollSelectableOptionsCount = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          _Internal::set_has_pollselectableoptionscount(&has_bits);
+          _impl_.pollselectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes messageSecret = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_messagesecret();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 senderTimestampMs = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          _Internal::set_has_sendertimestampms(&has_bits);
+          _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pollUpdateParentKey = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          auto str = _internal_mutable_pollupdateparentkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollUpdateParentKey");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PollEncValue encPollVote = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_encpollvote(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MsgOpaqueData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string body = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_body().data(), static_cast<int>(this->_internal_body().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.body");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_body(), target);
+  }
+
+  // optional string caption = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_caption().data(), static_cast<int>(this->_internal_caption().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.caption");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_caption(), target);
+  }
+
+  // optional double lng = 5;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(5, this->_internal_lng(), target);
+  }
+
+  // optional bool isLive = 6;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target);
+  }
+
+  // optional double lat = 7;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(7, this->_internal_lat(), target);
+  }
+
+  // optional int32 paymentAmount1000 = 8;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_paymentamount1000(), target);
+  }
+
+  // optional string paymentNoteMsgBody = 9;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_paymentnotemsgbody().data(), static_cast<int>(this->_internal_paymentnotemsgbody().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.paymentNoteMsgBody");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_paymentnotemsgbody(), target);
+  }
+
+  // optional string canonicalUrl = 10;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_canonicalurl().data(), static_cast<int>(this->_internal_canonicalurl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.canonicalUrl");
+    target = stream->WriteStringMaybeAliased(
+        10, this->_internal_canonicalurl(), target);
+  }
+
+  // optional string matchedText = 11;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_matchedtext().data(), static_cast<int>(this->_internal_matchedtext().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.matchedText");
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_matchedtext(), target);
+  }
+
+  // optional string title = 12;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_title().data(), static_cast<int>(this->_internal_title().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.title");
+    target = stream->WriteStringMaybeAliased(
+        12, this->_internal_title(), target);
+  }
+
+  // optional string description = 13;
+  if (cached_has_bits & 0x00000040u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.description");
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_description(), target);
+  }
+
+  // optional bytes futureproofBuffer = 14;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->WriteBytesMaybeAliased(
+        14, this->_internal_futureproofbuffer(), target);
+  }
+
+  // optional string clientUrl = 15;
+  if (cached_has_bits & 0x00000100u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_clienturl().data(), static_cast<int>(this->_internal_clienturl().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.clientUrl");
+    target = stream->WriteStringMaybeAliased(
+        15, this->_internal_clienturl(), target);
+  }
+
+  // optional string loc = 16;
+  if (cached_has_bits & 0x00000200u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_loc().data(), static_cast<int>(this->_internal_loc().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.loc");
+    target = stream->WriteStringMaybeAliased(
+        16, this->_internal_loc(), target);
+  }
+
+  // optional string pollName = 17;
+  if (cached_has_bits & 0x00000400u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pollname().data(), static_cast<int>(this->_internal_pollname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.pollName");
+    target = stream->WriteStringMaybeAliased(
+        17, this->_internal_pollname(), target);
+  }
+
+  // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_polloptions_size()); i < n; i++) {
+    const auto& repfield = this->_internal_polloptions(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(18, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 pollSelectableOptionsCount = 20;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_pollselectableoptionscount(), target);
+  }
+
+  // optional bytes messageSecret = 21;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->WriteBytesMaybeAliased(
+        21, this->_internal_messagesecret(), target);
+  }
+
+  // optional int64 senderTimestampMs = 22;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(22, this->_internal_sendertimestampms(), target);
+  }
+
+  // optional string pollUpdateParentKey = 23;
+  if (cached_has_bits & 0x00001000u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pollupdateparentkey().data(), static_cast<int>(this->_internal_pollupdateparentkey().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.MsgOpaqueData.pollUpdateParentKey");
+    target = stream->WriteStringMaybeAliased(
+        23, this->_internal_pollupdateparentkey(), target);
+  }
+
+  // optional .proto.PollEncValue encPollVote = 24;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(24, _Internal::encpollvote(this),
+        _Internal::encpollvote(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MsgOpaqueData)
+  return target;
+}
+
+size_t MsgOpaqueData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
+  total_size += 2UL * this->_internal_polloptions_size();
+  for (const auto& msg : this->_impl_.polloptions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string body = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_body());
+    }
+
+    // optional string caption = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_caption());
+    }
+
+    // optional string paymentNoteMsgBody = 9;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_paymentnotemsgbody());
+    }
+
+    // optional string canonicalUrl = 10;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_canonicalurl());
+    }
+
+    // optional string matchedText = 11;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_matchedtext());
+    }
+
+    // optional string title = 12;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_title());
+    }
+
+    // optional string description = 13;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional bytes futureproofBuffer = 14;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_futureproofbuffer());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional string clientUrl = 15;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_clienturl());
+    }
+
+    // optional string loc = 16;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_loc());
+    }
+
+    // optional string pollName = 17;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pollname());
+    }
+
+    // optional bytes messageSecret = 21;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_messagesecret());
+    }
+
+    // optional string pollUpdateParentKey = 23;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pollupdateparentkey());
+    }
+
+    // optional .proto.PollEncValue encPollVote = 24;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.encpollvote_);
+    }
+
+    // optional double lng = 5;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 + 8;
+    }
+
+    // optional double lat = 7;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    // optional bool isLive = 6;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional int32 paymentAmount1000 = 8;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_paymentamount1000());
+    }
+
+    // optional int64 senderTimestampMs = 22;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int64Size(
+          this->_internal_sendertimestampms());
+    }
+
+    // optional uint32 pollSelectableOptionsCount = 20;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_pollselectableoptionscount());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MsgOpaqueData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData::GetClassData() const { return &_class_data_; }
+
+
+void MsgOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MsgOpaqueData*>(&to_msg);
+  auto& from = static_cast<const MsgOpaqueData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.polloptions_.MergeFrom(from._impl_.polloptions_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_body(from._internal_body());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_caption(from._internal_caption());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_paymentnotemsgbody(from._internal_paymentnotemsgbody());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_canonicalurl(from._internal_canonicalurl());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_matchedtext(from._internal_matchedtext());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_title(from._internal_title());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_futureproofbuffer(from._internal_futureproofbuffer());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_set_clienturl(from._internal_clienturl());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_set_loc(from._internal_loc());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_set_pollname(from._internal_pollname());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_set_messagesecret(from._internal_messagesecret());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_set_pollupdateparentkey(from._internal_pollupdateparentkey());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_encpollvote()->::proto::PollEncValue::MergeFrom(
+          from._internal_encpollvote());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.lng_ = from._impl_.lng_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.lat_ = from._impl_.lat_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x000f0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.islive_ = from._impl_.islive_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.paymentamount1000_ = from._impl_.paymentamount1000_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.pollselectableoptionscount_ = from._impl_.pollselectableoptionscount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MsgOpaqueData::CopyFrom(const MsgOpaqueData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MsgOpaqueData::IsInitialized() const {
+  return true;
+}
+
+void MsgOpaqueData::InternalSwap(MsgOpaqueData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.polloptions_.InternalSwap(&other->_impl_.polloptions_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.caption_, lhs_arena,
+      &other->_impl_.caption_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.paymentnotemsgbody_, lhs_arena,
+      &other->_impl_.paymentnotemsgbody_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.canonicalurl_, lhs_arena,
+      &other->_impl_.canonicalurl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.matchedtext_, lhs_arena,
+      &other->_impl_.matchedtext_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.title_, lhs_arena,
+      &other->_impl_.title_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.futureproofbuffer_, lhs_arena,
+      &other->_impl_.futureproofbuffer_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.clienturl_, lhs_arena,
+      &other->_impl_.clienturl_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.loc_, lhs_arena,
+      &other->_impl_.loc_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pollname_, lhs_arena,
+      &other->_impl_.pollname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.messagesecret_, lhs_arena,
+      &other->_impl_.messagesecret_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pollupdateparentkey_, lhs_arena,
+      &other->_impl_.pollupdateparentkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.pollselectableoptionscount_)
+      + sizeof(MsgOpaqueData::_impl_.pollselectableoptionscount_)
+      - PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.encpollvote_)>(
+          reinterpret_cast<char*>(&_impl_.encpollvote_),
+          reinterpret_cast<char*>(&other->_impl_.encpollvote_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[142]);
+}
+
+// ===================================================================
+
+class MsgRowOpaqueData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<MsgRowOpaqueData>()._impl_._has_bits_);
+  static const ::proto::MsgOpaqueData& currentmsg(const MsgRowOpaqueData* msg);
+  static void set_has_currentmsg(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::MsgOpaqueData& quotedmsg(const MsgRowOpaqueData* msg);
+  static void set_has_quotedmsg(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::MsgOpaqueData&
+MsgRowOpaqueData::_Internal::currentmsg(const MsgRowOpaqueData* msg) {
+  return *msg->_impl_.currentmsg_;
+}
+const ::proto::MsgOpaqueData&
+MsgRowOpaqueData::_Internal::quotedmsg(const MsgRowOpaqueData* msg) {
+  return *msg->_impl_.quotedmsg_;
+}
+MsgRowOpaqueData::MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.MsgRowOpaqueData)
+}
+MsgRowOpaqueData::MsgRowOpaqueData(const MsgRowOpaqueData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  MsgRowOpaqueData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currentmsg_){nullptr}
+    , decltype(_impl_.quotedmsg_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_currentmsg()) {
+    _this->_impl_.currentmsg_ = new ::proto::MsgOpaqueData(*from._impl_.currentmsg_);
+  }
+  if (from._internal_has_quotedmsg()) {
+    _this->_impl_.quotedmsg_ = new ::proto::MsgOpaqueData(*from._impl_.quotedmsg_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.MsgRowOpaqueData)
+}
+
+inline void MsgRowOpaqueData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.currentmsg_){nullptr}
+    , decltype(_impl_.quotedmsg_){nullptr}
+  };
+}
+
+MsgRowOpaqueData::~MsgRowOpaqueData() {
+  // @@protoc_insertion_point(destructor:proto.MsgRowOpaqueData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void MsgRowOpaqueData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.currentmsg_;
+  if (this != internal_default_instance()) delete _impl_.quotedmsg_;
+}
+
+void MsgRowOpaqueData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void MsgRowOpaqueData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.MsgRowOpaqueData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.currentmsg_ != nullptr);
+      _impl_.currentmsg_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.quotedmsg_ != nullptr);
+      _impl_.quotedmsg_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* MsgRowOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MsgOpaqueData currentMsg = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_currentmsg(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MsgOpaqueData quotedMsg = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quotedmsg(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* MsgRowOpaqueData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.MsgRowOpaqueData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MsgOpaqueData currentMsg = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::currentmsg(this),
+        _Internal::currentmsg(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MsgOpaqueData quotedMsg = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::quotedmsg(this),
+        _Internal::quotedmsg(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.MsgRowOpaqueData)
+  return target;
+}
+
+size_t MsgRowOpaqueData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.MsgRowOpaqueData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.MsgOpaqueData currentMsg = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.currentmsg_);
+    }
+
+    // optional .proto.MsgOpaqueData quotedMsg = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quotedmsg_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgRowOpaqueData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    MsgRowOpaqueData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgRowOpaqueData::GetClassData() const { return &_class_data_; }
+
+
+void MsgRowOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<MsgRowOpaqueData*>(&to_msg);
+  auto& from = static_cast<const MsgRowOpaqueData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgRowOpaqueData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_currentmsg()->::proto::MsgOpaqueData::MergeFrom(
+          from._internal_currentmsg());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_quotedmsg()->::proto::MsgOpaqueData::MergeFrom(
+          from._internal_quotedmsg());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void MsgRowOpaqueData::CopyFrom(const MsgRowOpaqueData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgRowOpaqueData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MsgRowOpaqueData::IsInitialized() const {
+  return true;
+}
+
+void MsgRowOpaqueData::InternalSwap(MsgRowOpaqueData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.quotedmsg_)
+      + sizeof(MsgRowOpaqueData::_impl_.quotedmsg_)
+      - PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.currentmsg_)>(
+          reinterpret_cast<char*>(&_impl_.currentmsg_),
+          reinterpret_cast<char*>(&other->_impl_.currentmsg_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata MsgRowOpaqueData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[143]);
+}
+
+// ===================================================================
+
+class NoiseCertificate_Details::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NoiseCertificate_Details>()._impl_._has_bits_);
+  static void set_has_serial(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_issuer(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_expires(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_subject(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+NoiseCertificate_Details::NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate.Details)
+}
+NoiseCertificate_Details::NoiseCertificate_Details(const NoiseCertificate_Details& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NoiseCertificate_Details* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.issuer_){}
+    , decltype(_impl_.subject_){}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.expires_){}
+    , decltype(_impl_.serial_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.issuer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_issuer()) {
+    _this->_impl_.issuer_.Set(from._internal_issuer(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.subject_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.subject_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_subject()) {
+    _this->_impl_.subject_.Set(from._internal_subject(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_key()) {
+    _this->_impl_.key_.Set(from._internal_key(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.expires_, &from._impl_.expires_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.serial_) -
+    reinterpret_cast<char*>(&_impl_.expires_)) + sizeof(_impl_.serial_));
+  // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate.Details)
+}
+
+inline void NoiseCertificate_Details::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.issuer_){}
+    , decltype(_impl_.subject_){}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.expires_){uint64_t{0u}}
+    , decltype(_impl_.serial_){0u}
+  };
+  _impl_.issuer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.subject_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.subject_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NoiseCertificate_Details::~NoiseCertificate_Details() {
+  // @@protoc_insertion_point(destructor:proto.NoiseCertificate.Details)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NoiseCertificate_Details::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.issuer_.Destroy();
+  _impl_.subject_.Destroy();
+  _impl_.key_.Destroy();
+}
+
+void NoiseCertificate_Details::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NoiseCertificate_Details::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.issuer_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.subject_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.key_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000018u) {
+    ::memset(&_impl_.expires_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.serial_) -
+        reinterpret_cast<char*>(&_impl_.expires_)) + sizeof(_impl_.serial_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 serial = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_serial(&has_bits);
+          _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string issuer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_issuer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.issuer");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 expires = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_expires(&has_bits);
+          _impl_.expires_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string subject = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_subject();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.subject");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes key = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_key();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NoiseCertificate_Details::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 serial = 1;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target);
+  }
+
+  // optional string issuer = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_issuer().data(), static_cast<int>(this->_internal_issuer().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.NoiseCertificate.Details.issuer");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_issuer(), target);
+  }
+
+  // optional uint64 expires = 3;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_expires(), target);
+  }
+
+  // optional string subject = 4;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_subject().data(), static_cast<int>(this->_internal_subject().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.NoiseCertificate.Details.subject");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_subject(), target);
+  }
+
+  // optional bytes key = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_key(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.NoiseCertificate.Details)
+  return target;
+}
+
+size_t NoiseCertificate_Details::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate.Details)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string issuer = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_issuer());
+    }
+
+    // optional string subject = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_subject());
+    }
+
+    // optional bytes key = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_key());
+    }
+
+    // optional uint64 expires = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expires());
+    }
+
+    // optional uint32 serial = 1;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate_Details::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NoiseCertificate_Details::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate_Details::GetClassData() const { return &_class_data_; }
+
+
+void NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NoiseCertificate_Details*>(&to_msg);
+  auto& from = static_cast<const NoiseCertificate_Details&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate.Details)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_issuer(from._internal_issuer());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_subject(from._internal_subject());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_key(from._internal_key());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.expires_ = from._impl_.expires_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.serial_ = from._impl_.serial_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NoiseCertificate_Details::CopyFrom(const NoiseCertificate_Details& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate.Details)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NoiseCertificate_Details::IsInitialized() const {
+  return true;
+}
+
+void NoiseCertificate_Details::InternalSwap(NoiseCertificate_Details* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.issuer_, lhs_arena,
+      &other->_impl_.issuer_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.subject_, lhs_arena,
+      &other->_impl_.subject_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.key_, lhs_arena,
+      &other->_impl_.key_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.serial_)
+      + sizeof(NoiseCertificate_Details::_impl_.serial_)
+      - PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.expires_)>(
+          reinterpret_cast<char*>(&_impl_.expires_),
+          reinterpret_cast<char*>(&other->_impl_.expires_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate_Details::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[144]);
+}
+
+// ===================================================================
+
+class NoiseCertificate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NoiseCertificate>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+NoiseCertificate::NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate)
+}
+NoiseCertificate::NoiseCertificate(const NoiseCertificate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NoiseCertificate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_.Set(from._internal_signature(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate)
+}
+
+inline void NoiseCertificate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NoiseCertificate::~NoiseCertificate() {
+  // @@protoc_insertion_point(destructor:proto.NoiseCertificate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NoiseCertificate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.signature_.Destroy();
+}
+
+void NoiseCertificate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NoiseCertificate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.signature_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes signature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_signature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NoiseCertificate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes signature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_signature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.NoiseCertificate)
+  return target;
+}
+
+size_t NoiseCertificate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes signature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_signature());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NoiseCertificate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate::GetClassData() const { return &_class_data_; }
+
+
+void NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NoiseCertificate*>(&to_msg);
+  auto& from = static_cast<const NoiseCertificate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_signature(from._internal_signature());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NoiseCertificate::CopyFrom(const NoiseCertificate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NoiseCertificate::IsInitialized() const {
+  return true;
+}
+
+void NoiseCertificate::InternalSwap(NoiseCertificate* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.signature_, lhs_arena,
+      &other->_impl_.signature_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[145]);
+}
+
+// ===================================================================
+
+class NotificationMessageInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NotificationMessageInfo>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const NotificationMessageInfo* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::Message& message(const NotificationMessageInfo* msg);
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_messagetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_participant(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::MessageKey&
+NotificationMessageInfo::_Internal::key(const NotificationMessageInfo* msg) {
+  return *msg->_impl_.key_;
+}
+const ::proto::Message&
+NotificationMessageInfo::_Internal::message(const NotificationMessageInfo* msg) {
+  return *msg->_impl_.message_;
+}
+NotificationMessageInfo::NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.NotificationMessageInfo)
+}
+NotificationMessageInfo::NotificationMessageInfo(const NotificationMessageInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NotificationMessageInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.messagetimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_participant()) {
+    _this->_impl_.participant_.Set(from._internal_participant(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  if (from._internal_has_message()) {
+    _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_);
+  }
+  _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.NotificationMessageInfo)
+}
+
+inline void NotificationMessageInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.messagetimestamp_){uint64_t{0u}}
+  };
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NotificationMessageInfo::~NotificationMessageInfo() {
+  // @@protoc_insertion_point(destructor:proto.NotificationMessageInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NotificationMessageInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.participant_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.key_;
+  if (this != internal_default_instance()) delete _impl_.message_;
+}
+
+void NotificationMessageInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NotificationMessageInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.NotificationMessageInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.participant_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.message_ != nullptr);
+      _impl_.message_->Clear();
+    }
+  }
+  _impl_.messagetimestamp_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NotificationMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_message(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 messageTimestamp = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_messagetimestamp(&has_bits);
+          _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string participant = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_participant();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.NotificationMessageInfo.participant");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NotificationMessageInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.NotificationMessageInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message message = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::message(this),
+        _Internal::message(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint64 messageTimestamp = 3;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target);
+  }
+
+  // optional string participant = 4;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_participant().data(), static_cast<int>(this->_internal_participant().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.NotificationMessageInfo.participant");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_participant(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.NotificationMessageInfo)
+  return target;
+}
+
+size_t NotificationMessageInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.NotificationMessageInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string participant = 4;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_participant());
+    }
+
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional .proto.Message message = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.message_);
+    }
+
+    // optional uint64 messageTimestamp = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NotificationMessageInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NotificationMessageInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NotificationMessageInfo::GetClassData() const { return &_class_data_; }
+
+
+void NotificationMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NotificationMessageInfo*>(&to_msg);
+  auto& from = static_cast<const NotificationMessageInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.NotificationMessageInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_participant(from._internal_participant());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_message()->::proto::Message::MergeFrom(
+          from._internal_message());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NotificationMessageInfo::CopyFrom(const NotificationMessageInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.NotificationMessageInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NotificationMessageInfo::IsInitialized() const {
+  return true;
+}
+
+void NotificationMessageInfo::InternalSwap(NotificationMessageInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.participant_, lhs_arena,
+      &other->_impl_.participant_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.messagetimestamp_)
+      + sizeof(NotificationMessageInfo::_impl_.messagetimestamp_)
+      - PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NotificationMessageInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[146]);
+}
+
+// ===================================================================
+
+class PastParticipant::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PastParticipant>()._impl_._has_bits_);
+  static void set_has_userjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_leavereason(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_leavets(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
+  }
+};
+
+PastParticipant::PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PastParticipant)
+}
+PastParticipant::PastParticipant(const PastParticipant& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PastParticipant* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.leavets_){}
+    , decltype(_impl_.leavereason_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_userjid()) {
+    _this->_impl_.userjid_.Set(from._internal_userjid(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.leavets_, &from._impl_.leavets_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.leavereason_) -
+    reinterpret_cast<char*>(&_impl_.leavets_)) + sizeof(_impl_.leavereason_));
+  // @@protoc_insertion_point(copy_constructor:proto.PastParticipant)
+}
+
+inline void PastParticipant::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.leavets_){uint64_t{0u}}
+    , decltype(_impl_.leavereason_){0}
+  };
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PastParticipant::~PastParticipant() {
+  // @@protoc_insertion_point(destructor:proto.PastParticipant)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PastParticipant::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.userjid_.Destroy();
+}
+
+void PastParticipant::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PastParticipant::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PastParticipant)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.userjid_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.leavets_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.leavereason_) -
+        reinterpret_cast<char*>(&_impl_.leavets_)) + sizeof(_impl_.leavereason_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PastParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string userJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_userjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PastParticipant.userJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // required .proto.PastParticipant.LeaveReason leaveReason = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::PastParticipant_LeaveReason_IsValid(val))) {
+            _internal_set_leavereason(static_cast<::proto::PastParticipant_LeaveReason>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // required uint64 leaveTs = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_leavets(&has_bits);
+          _impl_.leavets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PastParticipant::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipant)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string userJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_userjid().data(), static_cast<int>(this->_internal_userjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PastParticipant.userJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_userjid(), target);
+  }
+
+  // required .proto.PastParticipant.LeaveReason leaveReason = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_leavereason(), target);
+  }
+
+  // required uint64 leaveTs = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_leavets(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PastParticipant)
+  return target;
+}
+
+size_t PastParticipant::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:proto.PastParticipant)
+  size_t total_size = 0;
+
+  if (_internal_has_userjid()) {
+    // required string userJid = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userjid());
+  }
+
+  if (_internal_has_leavets()) {
+    // required uint64 leaveTs = 3;
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets());
+  }
+
+  if (_internal_has_leavereason()) {
+    // required .proto.PastParticipant.LeaveReason leaveReason = 2;
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason());
+  }
+
+  return total_size;
+}
+size_t PastParticipant::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipant)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
+    // required string userJid = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userjid());
+
+    // required uint64 leaveTs = 3;
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets());
+
+    // required .proto.PastParticipant.LeaveReason leaveReason = 2;
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipant::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PastParticipant::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipant::GetClassData() const { return &_class_data_; }
+
+
+void PastParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PastParticipant*>(&to_msg);
+  auto& from = static_cast<const PastParticipant&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipant)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_userjid(from._internal_userjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.leavets_ = from._impl_.leavets_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.leavereason_ = from._impl_.leavereason_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PastParticipant::CopyFrom(const PastParticipant& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipant)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PastParticipant::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void PastParticipant::InternalSwap(PastParticipant* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.userjid_, lhs_arena,
+      &other->_impl_.userjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavereason_)
+      + sizeof(PastParticipant::_impl_.leavereason_)
+      - PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavets_)>(
+          reinterpret_cast<char*>(&_impl_.leavets_),
+          reinterpret_cast<char*>(&other->_impl_.leavets_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PastParticipant::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[147]);
+}
+
+// ===================================================================
+
+class PastParticipants::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PastParticipants>()._impl_._has_bits_);
+  static void set_has_groupjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+PastParticipants::PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PastParticipants)
+}
+PastParticipants::PastParticipants(const PastParticipants& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PastParticipants* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_}
+    , decltype(_impl_.groupjid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.groupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupjid()) {
+    _this->_impl_.groupjid_.Set(from._internal_groupjid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.PastParticipants)
+}
+
+inline void PastParticipants::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pastparticipants_){arena}
+    , decltype(_impl_.groupjid_){}
+  };
+  _impl_.groupjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PastParticipants::~PastParticipants() {
+  // @@protoc_insertion_point(destructor:proto.PastParticipants)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PastParticipants::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.pastparticipants_.~RepeatedPtrField();
+  _impl_.groupjid_.Destroy();
+}
+
+void PastParticipants::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PastParticipants::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PastParticipants)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.pastparticipants_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.groupjid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PastParticipants::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string groupJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_groupjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PastParticipants.groupJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.PastParticipant pastParticipants = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PastParticipants::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipants)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string groupJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupjid().data(), static_cast<int>(this->_internal_groupjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PastParticipants.groupJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_groupjid(), target);
+  }
+
+  // repeated .proto.PastParticipant pastParticipants = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_pastparticipants_size()); i < n; i++) {
+    const auto& repfield = this->_internal_pastparticipants(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PastParticipants)
+  return target;
+}
+
+size_t PastParticipants::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipants)
+  size_t total_size = 0;
+
+  // required string groupJid = 1;
+  if (_internal_has_groupjid()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_groupjid());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.PastParticipant pastParticipants = 2;
+  total_size += 1UL * this->_internal_pastparticipants_size();
+  for (const auto& msg : this->_impl_.pastparticipants_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipants::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PastParticipants::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipants::GetClassData() const { return &_class_data_; }
+
+
+void PastParticipants::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PastParticipants*>(&to_msg);
+  auto& from = static_cast<const PastParticipants&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipants)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_);
+  if (from._internal_has_groupjid()) {
+    _this->_internal_set_groupjid(from._internal_groupjid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PastParticipants::CopyFrom(const PastParticipants& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipants)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PastParticipants::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_))
+    return false;
+  return true;
+}
+
+void PastParticipants::InternalSwap(PastParticipants* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupjid_, lhs_arena,
+      &other->_impl_.groupjid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PastParticipants::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[148]);
+}
+
+// ===================================================================
+
+class PaymentBackground_MediaData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PaymentBackground_MediaData>()._impl_._has_bits_);
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mediakeytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+PaymentBackground_MediaData::PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground.MediaData)
+}
+PaymentBackground_MediaData::PaymentBackground_MediaData(const PaymentBackground_MediaData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PaymentBackground_MediaData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.mediakeytimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground.MediaData)
+}
+
+inline void PaymentBackground_MediaData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.mediakeytimestamp_){int64_t{0}}
+  };
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PaymentBackground_MediaData::~PaymentBackground_MediaData() {
+  // @@protoc_insertion_point(destructor:proto.PaymentBackground.MediaData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PaymentBackground_MediaData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mediakey_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.directpath_.Destroy();
+}
+
+void PaymentBackground_MediaData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PaymentBackground_MediaData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground.MediaData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PaymentBackground_MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes mediaKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 mediaKeyTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_mediakeytimestamp(&has_bits);
+          _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.MediaData.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PaymentBackground_MediaData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground.MediaData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes mediaKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_mediakey(), target);
+  }
+
+  // optional int64 mediaKeyTimestamp = 2;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_mediakeytimestamp(), target);
+  }
+
+  // optional bytes fileSha256 = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_filesha256(), target);
+  }
+
+  // optional bytes fileEncSha256 = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_fileencsha256(), target);
+  }
+
+  // optional string directPath = 5;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PaymentBackground.MediaData.directPath");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_directpath(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PaymentBackground.MediaData)
+  return target;
+}
+
+size_t PaymentBackground_MediaData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground.MediaData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes mediaKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional bytes fileSha256 = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes fileEncSha256 = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional string directPath = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional int64 mediaKeyTimestamp = 2;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground_MediaData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PaymentBackground_MediaData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground_MediaData::GetClassData() const { return &_class_data_; }
+
+
+void PaymentBackground_MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PaymentBackground_MediaData*>(&to_msg);
+  auto& from = static_cast<const PaymentBackground_MediaData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground.MediaData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PaymentBackground_MediaData::CopyFrom(const PaymentBackground_MediaData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground.MediaData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PaymentBackground_MediaData::IsInitialized() const {
+  return true;
+}
+
+void PaymentBackground_MediaData::InternalSwap(PaymentBackground_MediaData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  swap(_impl_.mediakeytimestamp_, other->_impl_.mediakeytimestamp_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground_MediaData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[149]);
+}
+
+// ===================================================================
+
+class PaymentBackground::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PaymentBackground>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_placeholderargb(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_textargb(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_subtextargb(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::PaymentBackground_MediaData& mediadata(const PaymentBackground* msg);
+  static void set_has_mediadata(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+const ::proto::PaymentBackground_MediaData&
+PaymentBackground::_Internal::mediadata(const PaymentBackground* msg) {
+  return *msg->_impl_.mediadata_;
+}
+PaymentBackground::PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground)
+}
+PaymentBackground::PaymentBackground(const PaymentBackground& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PaymentBackground* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.mediadata_){nullptr}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.placeholderargb_){}
+    , decltype(_impl_.textargb_){}
+    , decltype(_impl_.subtextargb_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_mediadata()) {
+    _this->_impl_.mediadata_ = new ::proto::PaymentBackground_MediaData(*from._impl_.mediadata_);
+  }
+  ::memcpy(&_impl_.filelength_, &from._impl_.filelength_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
+    reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.type_));
+  // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground)
+}
+
+inline void PaymentBackground::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.mediadata_){nullptr}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.placeholderargb_){0u}
+    , decltype(_impl_.textargb_){0u}
+    , decltype(_impl_.subtextargb_){0u}
+    , decltype(_impl_.type_){0}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PaymentBackground::~PaymentBackground() {
+  // @@protoc_insertion_point(destructor:proto.PaymentBackground)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PaymentBackground::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+  _impl_.mimetype_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.mediadata_;
+}
+
+void PaymentBackground::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PaymentBackground::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.mediadata_ != nullptr);
+      _impl_.mediadata_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000f8u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.textargb_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.textargb_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.subtextargb_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.type_) -
+        reinterpret_cast<char*>(&_impl_.subtextargb_)) + sizeof(_impl_.type_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PaymentBackground::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed32 placeholderArgb = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 53)) {
+          _Internal::set_has_placeholderargb(&has_bits);
+          _impl_.placeholderargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
+          ptr += sizeof(uint32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed32 textArgb = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 61)) {
+          _Internal::set_has_textargb(&has_bits);
+          _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
+          ptr += sizeof(uint32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed32 subtextArgb = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
+          _Internal::set_has_subtextargb(&has_bits);
+          _impl_.subtextargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
+          ptr += sizeof(uint32_t);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentBackground.MediaData mediaData = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentBackground.Type type = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::PaymentBackground_Type_IsValid(val))) {
+            _internal_set_type(static_cast<::proto::PaymentBackground_Type>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PaymentBackground::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PaymentBackground.id");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  // optional uint64 fileLength = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target);
+  }
+
+  // optional uint32 width = 3;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_width(), target);
+  }
+
+  // optional uint32 height = 4;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(), target);
+  }
+
+  // optional string mimetype = 5;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PaymentBackground.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_mimetype(), target);
+  }
+
+  // optional fixed32 placeholderArgb = 6;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(6, this->_internal_placeholderargb(), target);
+  }
+
+  // optional fixed32 textArgb = 7;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target);
+  }
+
+  // optional fixed32 subtextArgb = 8;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_subtextargb(), target);
+  }
+
+  // optional .proto.PaymentBackground.MediaData mediaData = 9;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::mediadata(this),
+        _Internal::mediadata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PaymentBackground.Type type = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PaymentBackground)
+  return target;
+}
+
+size_t PaymentBackground::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string id = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional string mimetype = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional .proto.PaymentBackground.MediaData mediaData = 9;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.mediadata_);
+    }
+
+    // optional uint64 fileLength = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional uint32 width = 3;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+    // optional uint32 height = 4;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional fixed32 placeholderArgb = 6;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 textArgb = 7;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional fixed32 subtextArgb = 8;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 4;
+    }
+
+    // optional .proto.PaymentBackground.Type type = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PaymentBackground::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground::GetClassData() const { return &_class_data_; }
+
+
+void PaymentBackground::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PaymentBackground*>(&to_msg);
+  auto& from = static_cast<const PaymentBackground&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_mediadata()->::proto::PaymentBackground_MediaData::MergeFrom(
+          from._internal_mediadata());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.placeholderargb_ = from._impl_.placeholderargb_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.textargb_ = from._impl_.textargb_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.subtextargb_ = from._impl_.subtextargb_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PaymentBackground::CopyFrom(const PaymentBackground& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PaymentBackground::IsInitialized() const {
+  return true;
+}
+
+void PaymentBackground::InternalSwap(PaymentBackground* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.type_)
+      + sizeof(PaymentBackground::_impl_.type_)
+      - PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.mediadata_)>(
+          reinterpret_cast<char*>(&_impl_.mediadata_),
+          reinterpret_cast<char*>(&other->_impl_.mediadata_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[150]);
+}
+
+// ===================================================================
+
+class PaymentInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PaymentInfo>()._impl_._has_bits_);
+  static void set_has_currencydeprecated(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_amount1000(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_receiverjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_status(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_transactiontimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::MessageKey& requestmessagekey(const PaymentInfo* msg);
+  static void set_has_requestmessagekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_expirytimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_futureproofed(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_currency(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_txnstatus(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_usenovifiatformat(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::Money& primaryamount(const PaymentInfo* msg);
+  static void set_has_primaryamount(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::Money& exchangeamount(const PaymentInfo* msg);
+  static void set_has_exchangeamount(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+const ::proto::MessageKey&
+PaymentInfo::_Internal::requestmessagekey(const PaymentInfo* msg) {
+  return *msg->_impl_.requestmessagekey_;
+}
+const ::proto::Money&
+PaymentInfo::_Internal::primaryamount(const PaymentInfo* msg) {
+  return *msg->_impl_.primaryamount_;
+}
+const ::proto::Money&
+PaymentInfo::_Internal::exchangeamount(const PaymentInfo* msg) {
+  return *msg->_impl_.exchangeamount_;
+}
+PaymentInfo::PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PaymentInfo)
+}
+PaymentInfo::PaymentInfo(const PaymentInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PaymentInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.receiverjid_){}
+    , decltype(_impl_.currency_){}
+    , decltype(_impl_.requestmessagekey_){nullptr}
+    , decltype(_impl_.primaryamount_){nullptr}
+    , decltype(_impl_.exchangeamount_){nullptr}
+    , decltype(_impl_.amount1000_){}
+    , decltype(_impl_.currencydeprecated_){}
+    , decltype(_impl_.status_){}
+    , decltype(_impl_.transactiontimestamp_){}
+    , decltype(_impl_.expirytimestamp_){}
+    , decltype(_impl_.futureproofed_){}
+    , decltype(_impl_.usenovifiatformat_){}
+    , decltype(_impl_.txnstatus_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.receiverjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.receiverjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_receiverjid()) {
+    _this->_impl_.receiverjid_.Set(from._internal_receiverjid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.currency_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currency_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_currency()) {
+    _this->_impl_.currency_.Set(from._internal_currency(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_requestmessagekey()) {
+    _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_);
+  }
+  if (from._internal_has_primaryamount()) {
+    _this->_impl_.primaryamount_ = new ::proto::Money(*from._impl_.primaryamount_);
+  }
+  if (from._internal_has_exchangeamount()) {
+    _this->_impl_.exchangeamount_ = new ::proto::Money(*from._impl_.exchangeamount_);
+  }
+  ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.txnstatus_) -
+    reinterpret_cast<char*>(&_impl_.amount1000_)) + sizeof(_impl_.txnstatus_));
+  // @@protoc_insertion_point(copy_constructor:proto.PaymentInfo)
+}
+
+inline void PaymentInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.receiverjid_){}
+    , decltype(_impl_.currency_){}
+    , decltype(_impl_.requestmessagekey_){nullptr}
+    , decltype(_impl_.primaryamount_){nullptr}
+    , decltype(_impl_.exchangeamount_){nullptr}
+    , decltype(_impl_.amount1000_){uint64_t{0u}}
+    , decltype(_impl_.currencydeprecated_){0}
+    , decltype(_impl_.status_){0}
+    , decltype(_impl_.transactiontimestamp_){uint64_t{0u}}
+    , decltype(_impl_.expirytimestamp_){uint64_t{0u}}
+    , decltype(_impl_.futureproofed_){false}
+    , decltype(_impl_.usenovifiatformat_){false}
+    , decltype(_impl_.txnstatus_){0}
+  };
+  _impl_.receiverjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.receiverjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.currency_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.currency_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PaymentInfo::~PaymentInfo() {
+  // @@protoc_insertion_point(destructor:proto.PaymentInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PaymentInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.receiverjid_.Destroy();
+  _impl_.currency_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.requestmessagekey_;
+  if (this != internal_default_instance()) delete _impl_.primaryamount_;
+  if (this != internal_default_instance()) delete _impl_.exchangeamount_;
+}
+
+void PaymentInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PaymentInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PaymentInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.receiverjid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.currency_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr);
+      _impl_.requestmessagekey_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.primaryamount_ != nullptr);
+      _impl_.primaryamount_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.exchangeamount_ != nullptr);
+      _impl_.exchangeamount_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    ::memset(&_impl_.amount1000_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.status_) -
+        reinterpret_cast<char*>(&_impl_.amount1000_)) + sizeof(_impl_.status_));
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    ::memset(&_impl_.transactiontimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.txnstatus_) -
+        reinterpret_cast<char*>(&_impl_.transactiontimestamp_)) + sizeof(_impl_.txnstatus_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PaymentInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Currency_IsValid(val))) {
+            _internal_set_currencydeprecated(static_cast<::proto::PaymentInfo_Currency>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 amount1000 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_amount1000(&has_bits);
+          _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string receiverJid = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_receiverjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.receiverJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentInfo.Status status = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Status_IsValid(val))) {
+            _internal_set_status(static_cast<::proto::PaymentInfo_Status>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 transactionTimestamp = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_transactiontimestamp(&has_bits);
+          _impl_.transactiontimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MessageKey requestMessageKey = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 expiryTimestamp = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_expirytimestamp(&has_bits);
+          _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool futureproofed = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_futureproofed(&has_bits);
+          _impl_.futureproofed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string currency = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_currency();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.currency");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_TxnStatus_IsValid(val))) {
+            _internal_set_txnstatus(static_cast<::proto::PaymentInfo_TxnStatus>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool useNoviFiatFormat = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_usenovifiatformat(&has_bits);
+          _impl_.usenovifiatformat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Money primaryAmount = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_primaryamount(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Money exchangeAmount = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_exchangeamount(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PaymentInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_currencydeprecated(), target);
+  }
+
+  // optional uint64 amount1000 = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target);
+  }
+
+  // optional string receiverJid = 3;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_receiverjid().data(), static_cast<int>(this->_internal_receiverjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PaymentInfo.receiverJid");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_receiverjid(), target);
+  }
+
+  // optional .proto.PaymentInfo.Status status = 4;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_status(), target);
+  }
+
+  // optional uint64 transactionTimestamp = 5;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_transactiontimestamp(), target);
+  }
+
+  // optional .proto.MessageKey requestMessageKey = 6;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::requestmessagekey(this),
+        _Internal::requestmessagekey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint64 expiryTimestamp = 7;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_expirytimestamp(), target);
+  }
+
+  // optional bool futureproofed = 8;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_futureproofed(), target);
+  }
+
+  // optional string currency = 9;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_currency().data(), static_cast<int>(this->_internal_currency().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.PaymentInfo.currency");
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_currency(), target);
+  }
+
+  // optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_txnstatus(), target);
+  }
+
+  // optional bool useNoviFiatFormat = 11;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_usenovifiatformat(), target);
+  }
+
+  // optional .proto.Money primaryAmount = 12;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(12, _Internal::primaryamount(this),
+        _Internal::primaryamount(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Money exchangeAmount = 13;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(13, _Internal::exchangeamount(this),
+        _Internal::exchangeamount(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PaymentInfo)
+  return target;
+}
+
+size_t PaymentInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PaymentInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string receiverJid = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_receiverjid());
+    }
+
+    // optional string currency = 9;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_currency());
+    }
+
+    // optional .proto.MessageKey requestMessageKey = 6;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.requestmessagekey_);
+    }
+
+    // optional .proto.Money primaryAmount = 12;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.primaryamount_);
+    }
+
+    // optional .proto.Money exchangeAmount = 13;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.exchangeamount_);
+    }
+
+    // optional uint64 amount1000 = 2;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000());
+    }
+
+    // optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_currencydeprecated());
+    }
+
+    // optional .proto.PaymentInfo.Status status = 4;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
+    }
+
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    // optional uint64 transactionTimestamp = 5;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_transactiontimestamp());
+    }
+
+    // optional uint64 expiryTimestamp = 7;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expirytimestamp());
+    }
+
+    // optional bool futureproofed = 8;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool useNoviFiatFormat = 11;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 + 1;
+    }
+
+    // optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_txnstatus());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PaymentInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentInfo::GetClassData() const { return &_class_data_; }
+
+
+void PaymentInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PaymentInfo*>(&to_msg);
+  auto& from = static_cast<const PaymentInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_receiverjid(from._internal_receiverjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_currency(from._internal_currency());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom(
+          from._internal_requestmessagekey());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_primaryamount()->::proto::Money::MergeFrom(
+          from._internal_primaryamount());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_exchangeamount()->::proto::Money::MergeFrom(
+          from._internal_exchangeamount());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.amount1000_ = from._impl_.amount1000_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.currencydeprecated_ = from._impl_.currencydeprecated_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.status_ = from._impl_.status_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.transactiontimestamp_ = from._impl_.transactiontimestamp_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.futureproofed_ = from._impl_.futureproofed_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.usenovifiatformat_ = from._impl_.usenovifiatformat_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.txnstatus_ = from._impl_.txnstatus_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PaymentInfo::CopyFrom(const PaymentInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PaymentInfo::IsInitialized() const {
+  return true;
+}
+
+void PaymentInfo::InternalSwap(PaymentInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.receiverjid_, lhs_arena,
+      &other->_impl_.receiverjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.currency_, lhs_arena,
+      &other->_impl_.currency_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.txnstatus_)
+      + sizeof(PaymentInfo::_impl_.txnstatus_)
+      - PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.requestmessagekey_)>(
+          reinterpret_cast<char*>(&_impl_.requestmessagekey_),
+          reinterpret_cast<char*>(&other->_impl_.requestmessagekey_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PaymentInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[151]);
+}
+
+// ===================================================================
+
+class PendingKeyExchange::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PendingKeyExchange>()._impl_._has_bits_);
+  static void set_has_sequence(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_localbasekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_localbasekeyprivate(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_localratchetkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_localratchetkeyprivate(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_localidentitykey(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_localidentitykeyprivate(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+PendingKeyExchange::PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PendingKeyExchange)
+}
+PendingKeyExchange::PendingKeyExchange(const PendingKeyExchange& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PendingKeyExchange* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localbasekey_){}
+    , decltype(_impl_.localbasekeyprivate_){}
+    , decltype(_impl_.localratchetkey_){}
+    , decltype(_impl_.localratchetkeyprivate_){}
+    , decltype(_impl_.localidentitykey_){}
+    , decltype(_impl_.localidentitykeyprivate_){}
+    , decltype(_impl_.sequence_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.localbasekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localbasekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localbasekey()) {
+    _this->_impl_.localbasekey_.Set(from._internal_localbasekey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localbasekeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localbasekeyprivate()) {
+    _this->_impl_.localbasekeyprivate_.Set(from._internal_localbasekeyprivate(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localratchetkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localratchetkey()) {
+    _this->_impl_.localratchetkey_.Set(from._internal_localratchetkey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localratchetkeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localratchetkeyprivate()) {
+    _this->_impl_.localratchetkeyprivate_.Set(from._internal_localratchetkeyprivate(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localidentitykey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localidentitykey()) {
+    _this->_impl_.localidentitykey_.Set(from._internal_localidentitykey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.localidentitykeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localidentitykeyprivate()) {
+    _this->_impl_.localidentitykeyprivate_.Set(from._internal_localidentitykeyprivate(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.sequence_ = from._impl_.sequence_;
+  // @@protoc_insertion_point(copy_constructor:proto.PendingKeyExchange)
+}
+
+inline void PendingKeyExchange::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localbasekey_){}
+    , decltype(_impl_.localbasekeyprivate_){}
+    , decltype(_impl_.localratchetkey_){}
+    , decltype(_impl_.localratchetkeyprivate_){}
+    , decltype(_impl_.localidentitykey_){}
+    , decltype(_impl_.localidentitykeyprivate_){}
+    , decltype(_impl_.sequence_){0u}
+  };
+  _impl_.localbasekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localbasekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localbasekeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localratchetkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localratchetkeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localidentitykey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.localidentitykeyprivate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PendingKeyExchange::~PendingKeyExchange() {
+  // @@protoc_insertion_point(destructor:proto.PendingKeyExchange)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PendingKeyExchange::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.localbasekey_.Destroy();
+  _impl_.localbasekeyprivate_.Destroy();
+  _impl_.localratchetkey_.Destroy();
+  _impl_.localratchetkeyprivate_.Destroy();
+  _impl_.localidentitykey_.Destroy();
+  _impl_.localidentitykeyprivate_.Destroy();
+}
+
+void PendingKeyExchange::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PendingKeyExchange::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PendingKeyExchange)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.localbasekey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.localbasekeyprivate_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.localratchetkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.localratchetkeyprivate_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.localidentitykey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.localidentitykeyprivate_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.sequence_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PendingKeyExchange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 sequence = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_sequence(&has_bits);
+          _impl_.sequence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localBaseKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_localbasekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localBaseKeyPrivate = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_localbasekeyprivate();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localRatchetKey = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_localratchetkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localRatchetKeyPrivate = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_localratchetkeyprivate();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localIdentityKey = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_localidentitykey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localIdentityKeyPrivate = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_localidentitykeyprivate();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PendingKeyExchange::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PendingKeyExchange)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 sequence = 1;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sequence(), target);
+  }
+
+  // optional bytes localBaseKey = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_localbasekey(), target);
+  }
+
+  // optional bytes localBaseKeyPrivate = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_localbasekeyprivate(), target);
+  }
+
+  // optional bytes localRatchetKey = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_localratchetkey(), target);
+  }
+
+  // optional bytes localRatchetKeyPrivate = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_localratchetkeyprivate(), target);
+  }
+
+  // optional bytes localIdentityKey = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        7, this->_internal_localidentitykey(), target);
+  }
+
+  // optional bytes localIdentityKeyPrivate = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteBytesMaybeAliased(
+        8, this->_internal_localidentitykeyprivate(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PendingKeyExchange)
+  return target;
+}
+
+size_t PendingKeyExchange::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PendingKeyExchange)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional bytes localBaseKey = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localbasekey());
+    }
+
+    // optional bytes localBaseKeyPrivate = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localbasekeyprivate());
+    }
+
+    // optional bytes localRatchetKey = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localratchetkey());
+    }
+
+    // optional bytes localRatchetKeyPrivate = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localratchetkeyprivate());
+    }
+
+    // optional bytes localIdentityKey = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localidentitykey());
+    }
+
+    // optional bytes localIdentityKeyPrivate = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localidentitykeyprivate());
+    }
+
+    // optional uint32 sequence = 1;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sequence());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingKeyExchange::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PendingKeyExchange::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingKeyExchange::GetClassData() const { return &_class_data_; }
+
+
+void PendingKeyExchange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PendingKeyExchange*>(&to_msg);
+  auto& from = static_cast<const PendingKeyExchange&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingKeyExchange)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_localbasekey(from._internal_localbasekey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_localbasekeyprivate(from._internal_localbasekeyprivate());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_localratchetkey(from._internal_localratchetkey());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_localratchetkeyprivate(from._internal_localratchetkeyprivate());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_localidentitykey(from._internal_localidentitykey());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_localidentitykeyprivate(from._internal_localidentitykeyprivate());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.sequence_ = from._impl_.sequence_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PendingKeyExchange::CopyFrom(const PendingKeyExchange& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingKeyExchange)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PendingKeyExchange::IsInitialized() const {
+  return true;
+}
+
+void PendingKeyExchange::InternalSwap(PendingKeyExchange* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localbasekey_, lhs_arena,
+      &other->_impl_.localbasekey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localbasekeyprivate_, lhs_arena,
+      &other->_impl_.localbasekeyprivate_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localratchetkey_, lhs_arena,
+      &other->_impl_.localratchetkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localratchetkeyprivate_, lhs_arena,
+      &other->_impl_.localratchetkeyprivate_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localidentitykey_, lhs_arena,
+      &other->_impl_.localidentitykey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localidentitykeyprivate_, lhs_arena,
+      &other->_impl_.localidentitykeyprivate_, rhs_arena
+  );
+  swap(_impl_.sequence_, other->_impl_.sequence_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PendingKeyExchange::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[152]);
+}
+
+// ===================================================================
+
+class PendingPreKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PendingPreKey>()._impl_._has_bits_);
+  static void set_has_prekeyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_signedprekeyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_basekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+PendingPreKey::PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PendingPreKey)
+}
+PendingPreKey::PendingPreKey(const PendingPreKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PendingPreKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.basekey_){}
+    , decltype(_impl_.prekeyid_){}
+    , decltype(_impl_.signedprekeyid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.basekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.basekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_basekey()) {
+    _this->_impl_.basekey_.Set(from._internal_basekey(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.prekeyid_, &from._impl_.prekeyid_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.signedprekeyid_) -
+    reinterpret_cast<char*>(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_));
+  // @@protoc_insertion_point(copy_constructor:proto.PendingPreKey)
+}
+
+inline void PendingPreKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.basekey_){}
+    , decltype(_impl_.prekeyid_){0u}
+    , decltype(_impl_.signedprekeyid_){0}
+  };
+  _impl_.basekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.basekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PendingPreKey::~PendingPreKey() {
+  // @@protoc_insertion_point(destructor:proto.PendingPreKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PendingPreKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.basekey_.Destroy();
+}
+
+void PendingPreKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PendingPreKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PendingPreKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.basekey_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.prekeyid_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.signedprekeyid_) -
+        reinterpret_cast<char*>(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PendingPreKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 preKeyId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_prekeyid(&has_bits);
+          _impl_.prekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes baseKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_basekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 signedPreKeyId = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_signedprekeyid(&has_bits);
+          _impl_.signedprekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PendingPreKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PendingPreKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 preKeyId = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_prekeyid(), target);
+  }
+
+  // optional bytes baseKey = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_basekey(), target);
+  }
+
+  // optional int32 signedPreKeyId = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_signedprekeyid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PendingPreKey)
+  return target;
+}
+
+size_t PendingPreKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PendingPreKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes baseKey = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_basekey());
+    }
+
+    // optional uint32 preKeyId = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_prekeyid());
+    }
+
+    // optional int32 signedPreKeyId = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_signedprekeyid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingPreKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PendingPreKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingPreKey::GetClassData() const { return &_class_data_; }
+
+
+void PendingPreKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PendingPreKey*>(&to_msg);
+  auto& from = static_cast<const PendingPreKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingPreKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_basekey(from._internal_basekey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.prekeyid_ = from._impl_.prekeyid_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.signedprekeyid_ = from._impl_.signedprekeyid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PendingPreKey::CopyFrom(const PendingPreKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingPreKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PendingPreKey::IsInitialized() const {
+  return true;
+}
+
+void PendingPreKey::InternalSwap(PendingPreKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.basekey_, lhs_arena,
+      &other->_impl_.basekey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.signedprekeyid_)
+      + sizeof(PendingPreKey::_impl_.signedprekeyid_)
+      - PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.prekeyid_)>(
+          reinterpret_cast<char*>(&_impl_.prekeyid_),
+          reinterpret_cast<char*>(&other->_impl_.prekeyid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PendingPreKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[153]);
+}
+
+// ===================================================================
+
+class PhotoChange::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PhotoChange>()._impl_._has_bits_);
+  static void set_has_oldphoto(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_newphoto(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_newphotoid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+PhotoChange::PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PhotoChange)
+}
+PhotoChange::PhotoChange(const PhotoChange& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PhotoChange* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.oldphoto_){}
+    , decltype(_impl_.newphoto_){}
+    , decltype(_impl_.newphotoid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.oldphoto_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.oldphoto_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_oldphoto()) {
+    _this->_impl_.oldphoto_.Set(from._internal_oldphoto(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.newphoto_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.newphoto_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_newphoto()) {
+    _this->_impl_.newphoto_.Set(from._internal_newphoto(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.newphotoid_ = from._impl_.newphotoid_;
+  // @@protoc_insertion_point(copy_constructor:proto.PhotoChange)
+}
+
+inline void PhotoChange::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.oldphoto_){}
+    , decltype(_impl_.newphoto_){}
+    , decltype(_impl_.newphotoid_){0u}
+  };
+  _impl_.oldphoto_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.oldphoto_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.newphoto_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.newphoto_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PhotoChange::~PhotoChange() {
+  // @@protoc_insertion_point(destructor:proto.PhotoChange)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PhotoChange::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.oldphoto_.Destroy();
+  _impl_.newphoto_.Destroy();
+}
+
+void PhotoChange::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PhotoChange::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PhotoChange)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.oldphoto_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.newphoto_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.newphotoid_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PhotoChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes oldPhoto = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_oldphoto();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes newPhoto = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_newphoto();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 newPhotoId = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_newphotoid(&has_bits);
+          _impl_.newphotoid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PhotoChange::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PhotoChange)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes oldPhoto = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_oldphoto(), target);
+  }
+
+  // optional bytes newPhoto = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_newphoto(), target);
+  }
+
+  // optional uint32 newPhotoId = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_newphotoid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PhotoChange)
+  return target;
+}
+
+size_t PhotoChange::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PhotoChange)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes oldPhoto = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_oldphoto());
+    }
+
+    // optional bytes newPhoto = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_newphoto());
+    }
+
+    // optional uint32 newPhotoId = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_newphotoid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PhotoChange::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PhotoChange::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PhotoChange::GetClassData() const { return &_class_data_; }
+
+
+void PhotoChange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PhotoChange*>(&to_msg);
+  auto& from = static_cast<const PhotoChange&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PhotoChange)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_oldphoto(from._internal_oldphoto());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_newphoto(from._internal_newphoto());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.newphotoid_ = from._impl_.newphotoid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PhotoChange::CopyFrom(const PhotoChange& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PhotoChange)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PhotoChange::IsInitialized() const {
+  return true;
+}
+
+void PhotoChange::InternalSwap(PhotoChange* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.oldphoto_, lhs_arena,
+      &other->_impl_.oldphoto_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.newphoto_, lhs_arena,
+      &other->_impl_.newphoto_, rhs_arena
+  );
+  swap(_impl_.newphotoid_, other->_impl_.newphotoid_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PhotoChange::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[154]);
+}
+
+// ===================================================================
+
+class Point::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Point>()._impl_._has_bits_);
+  static void set_has_xdeprecated(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_ydeprecated(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_x(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_y(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+Point::Point(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Point)
+}
+Point::Point(const Point& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Point* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.xdeprecated_){}
+    , decltype(_impl_.ydeprecated_){}
+    , decltype(_impl_.x_){}
+    , decltype(_impl_.y_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.xdeprecated_, &from._impl_.xdeprecated_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.y_) -
+    reinterpret_cast<char*>(&_impl_.xdeprecated_)) + sizeof(_impl_.y_));
+  // @@protoc_insertion_point(copy_constructor:proto.Point)
+}
+
+inline void Point::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.xdeprecated_){0}
+    , decltype(_impl_.ydeprecated_){0}
+    , decltype(_impl_.x_){0}
+    , decltype(_impl_.y_){0}
+  };
+}
+
+Point::~Point() {
+  // @@protoc_insertion_point(destructor:proto.Point)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Point::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Point::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Point::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Point)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    ::memset(&_impl_.xdeprecated_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.y_) -
+        reinterpret_cast<char*>(&_impl_.xdeprecated_)) + sizeof(_impl_.y_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Point::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 xDeprecated = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_xdeprecated(&has_bits);
+          _impl_.xdeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 yDeprecated = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_ydeprecated(&has_bits);
+          _impl_.ydeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double x = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
+          _Internal::set_has_x(&has_bits);
+          _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double y = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
+          _Internal::set_has_y(&has_bits);
+          _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Point::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Point)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 xDeprecated = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_xdeprecated(), target);
+  }
+
+  // optional int32 yDeprecated = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_ydeprecated(), target);
+  }
+
+  // optional double x = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_x(), target);
+  }
+
+  // optional double y = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(4, this->_internal_y(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Point)
+  return target;
+}
+
+size_t Point::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Point)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional int32 xDeprecated = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_xdeprecated());
+    }
+
+    // optional int32 yDeprecated = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ydeprecated());
+    }
+
+    // optional double x = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 8;
+    }
+
+    // optional double y = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 8;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Point::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Point::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Point::GetClassData() const { return &_class_data_; }
+
+
+void Point::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Point*>(&to_msg);
+  auto& from = static_cast<const Point&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Point)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.xdeprecated_ = from._impl_.xdeprecated_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.ydeprecated_ = from._impl_.ydeprecated_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.x_ = from._impl_.x_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.y_ = from._impl_.y_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Point::CopyFrom(const Point& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Point)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Point::IsInitialized() const {
+  return true;
+}
+
+void Point::InternalSwap(Point* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Point, _impl_.y_)
+      + sizeof(Point::_impl_.y_)
+      - PROTOBUF_FIELD_OFFSET(Point, _impl_.xdeprecated_)>(
+          reinterpret_cast<char*>(&_impl_.xdeprecated_),
+          reinterpret_cast<char*>(&other->_impl_.xdeprecated_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Point::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[155]);
+}
+
+// ===================================================================
+
+class PollAdditionalMetadata::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PollAdditionalMetadata>()._impl_._has_bits_);
+  static void set_has_pollinvalidated(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+PollAdditionalMetadata::PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PollAdditionalMetadata)
+}
+PollAdditionalMetadata::PollAdditionalMetadata(const PollAdditionalMetadata& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PollAdditionalMetadata* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollinvalidated_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.pollinvalidated_ = from._impl_.pollinvalidated_;
+  // @@protoc_insertion_point(copy_constructor:proto.PollAdditionalMetadata)
+}
+
+inline void PollAdditionalMetadata::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollinvalidated_){false}
+  };
+}
+
+PollAdditionalMetadata::~PollAdditionalMetadata() {
+  // @@protoc_insertion_point(destructor:proto.PollAdditionalMetadata)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PollAdditionalMetadata::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void PollAdditionalMetadata::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PollAdditionalMetadata::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PollAdditionalMetadata)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.pollinvalidated_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PollAdditionalMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool pollInvalidated = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_pollinvalidated(&has_bits);
+          _impl_.pollinvalidated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PollAdditionalMetadata::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PollAdditionalMetadata)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool pollInvalidated = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pollinvalidated(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PollAdditionalMetadata)
+  return target;
+}
+
+size_t PollAdditionalMetadata::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PollAdditionalMetadata)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool pollInvalidated = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollAdditionalMetadata::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PollAdditionalMetadata::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollAdditionalMetadata::GetClassData() const { return &_class_data_; }
+
+
+void PollAdditionalMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PollAdditionalMetadata*>(&to_msg);
+  auto& from = static_cast<const PollAdditionalMetadata&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollAdditionalMetadata)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_pollinvalidated()) {
+    _this->_internal_set_pollinvalidated(from._internal_pollinvalidated());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PollAdditionalMetadata::CopyFrom(const PollAdditionalMetadata& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollAdditionalMetadata)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PollAdditionalMetadata::IsInitialized() const {
+  return true;
+}
+
+void PollAdditionalMetadata::InternalSwap(PollAdditionalMetadata* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.pollinvalidated_, other->_impl_.pollinvalidated_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PollAdditionalMetadata::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[156]);
+}
+
+// ===================================================================
+
+class PollEncValue::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PollEncValue>()._impl_._has_bits_);
+  static void set_has_encpayload(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_enciv(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+PollEncValue::PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PollEncValue)
+}
+PollEncValue::PollEncValue(const PollEncValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PollEncValue* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.encpayload_){}
+    , decltype(_impl_.enciv_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.encpayload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_encpayload()) {
+    _this->_impl_.encpayload_.Set(from._internal_encpayload(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.enciv_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_enciv()) {
+    _this->_impl_.enciv_.Set(from._internal_enciv(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.PollEncValue)
+}
+
+inline void PollEncValue::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.encpayload_){}
+    , decltype(_impl_.enciv_){}
+  };
+  _impl_.encpayload_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.enciv_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PollEncValue::~PollEncValue() {
+  // @@protoc_insertion_point(destructor:proto.PollEncValue)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PollEncValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.encpayload_.Destroy();
+  _impl_.enciv_.Destroy();
+}
+
+void PollEncValue::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PollEncValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PollEncValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.encpayload_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.enciv_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes encPayload = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_encpayload();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes encIv = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_enciv();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PollEncValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PollEncValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes encPayload = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_encpayload(), target);
+  }
+
+  // optional bytes encIv = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_enciv(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PollEncValue)
+  return target;
+}
+
+size_t PollEncValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PollEncValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes encPayload = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_encpayload());
+    }
+
+    // optional bytes encIv = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_enciv());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollEncValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PollEncValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollEncValue::GetClassData() const { return &_class_data_; }
+
+
+void PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PollEncValue*>(&to_msg);
+  auto& from = static_cast<const PollEncValue&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollEncValue)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_encpayload(from._internal_encpayload());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_enciv(from._internal_enciv());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PollEncValue::CopyFrom(const PollEncValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollEncValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PollEncValue::IsInitialized() const {
+  return true;
+}
+
+void PollEncValue::InternalSwap(PollEncValue* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.encpayload_, lhs_arena,
+      &other->_impl_.encpayload_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.enciv_, lhs_arena,
+      &other->_impl_.enciv_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PollEncValue::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[157]);
+}
+
+// ===================================================================
+
+class PollUpdate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PollUpdate>()._impl_._has_bits_);
+  static const ::proto::MessageKey& pollupdatemessagekey(const PollUpdate* msg);
+  static void set_has_pollupdatemessagekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_PollVoteMessage& vote(const PollUpdate* msg);
+  static void set_has_vote(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_sendertimestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::MessageKey&
+PollUpdate::_Internal::pollupdatemessagekey(const PollUpdate* msg) {
+  return *msg->_impl_.pollupdatemessagekey_;
+}
+const ::proto::Message_PollVoteMessage&
+PollUpdate::_Internal::vote(const PollUpdate* msg) {
+  return *msg->_impl_.vote_;
+}
+PollUpdate::PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PollUpdate)
+}
+PollUpdate::PollUpdate(const PollUpdate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PollUpdate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollupdatemessagekey_){nullptr}
+    , decltype(_impl_.vote_){nullptr}
+    , decltype(_impl_.sendertimestampms_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_pollupdatemessagekey()) {
+    _this->_impl_.pollupdatemessagekey_ = new ::proto::MessageKey(*from._impl_.pollupdatemessagekey_);
+  }
+  if (from._internal_has_vote()) {
+    _this->_impl_.vote_ = new ::proto::Message_PollVoteMessage(*from._impl_.vote_);
+  }
+  _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+  // @@protoc_insertion_point(copy_constructor:proto.PollUpdate)
+}
+
+inline void PollUpdate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pollupdatemessagekey_){nullptr}
+    , decltype(_impl_.vote_){nullptr}
+    , decltype(_impl_.sendertimestampms_){int64_t{0}}
+  };
+}
+
+PollUpdate::~PollUpdate() {
+  // @@protoc_insertion_point(destructor:proto.PollUpdate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PollUpdate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.pollupdatemessagekey_;
+  if (this != internal_default_instance()) delete _impl_.vote_;
+}
+
+void PollUpdate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PollUpdate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PollUpdate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.pollupdatemessagekey_ != nullptr);
+      _impl_.pollupdatemessagekey_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.vote_ != nullptr);
+      _impl_.vote_->Clear();
+    }
+  }
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PollUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey pollUpdateMessageKey = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessagekey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.PollVoteMessage vote = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 senderTimestampMs = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_sendertimestampms(&has_bits);
+          _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PollUpdate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PollUpdate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey pollUpdateMessageKey = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::pollupdatemessagekey(this),
+        _Internal::pollupdatemessagekey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.PollVoteMessage vote = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::vote(this),
+        _Internal::vote(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 senderTimestampMs = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_sendertimestampms(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PollUpdate)
+  return target;
+}
+
+size_t PollUpdate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PollUpdate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.MessageKey pollUpdateMessageKey = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pollupdatemessagekey_);
+    }
+
+    // optional .proto.Message.PollVoteMessage vote = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.vote_);
+    }
+
+    // optional int64 senderTimestampMs = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollUpdate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PollUpdate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollUpdate::GetClassData() const { return &_class_data_; }
+
+
+void PollUpdate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PollUpdate*>(&to_msg);
+  auto& from = static_cast<const PollUpdate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollUpdate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_pollupdatemessagekey()->::proto::MessageKey::MergeFrom(
+          from._internal_pollupdatemessagekey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_vote()->::proto::Message_PollVoteMessage::MergeFrom(
+          from._internal_vote());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PollUpdate::CopyFrom(const PollUpdate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollUpdate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PollUpdate::IsInitialized() const {
+  return true;
+}
+
+void PollUpdate::InternalSwap(PollUpdate* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.sendertimestampms_)
+      + sizeof(PollUpdate::_impl_.sendertimestampms_)
+      - PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.pollupdatemessagekey_)>(
+          reinterpret_cast<char*>(&_impl_.pollupdatemessagekey_),
+          reinterpret_cast<char*>(&other->_impl_.pollupdatemessagekey_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PollUpdate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[158]);
+}
+
+// ===================================================================
+
+class PreKeyRecordStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<PreKeyRecordStructure>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_publickey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_privatekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+PreKeyRecordStructure::PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.PreKeyRecordStructure)
+}
+PreKeyRecordStructure::PreKeyRecordStructure(const PreKeyRecordStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PreKeyRecordStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_publickey()) {
+    _this->_impl_.publickey_.Set(from._internal_publickey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_privatekey()) {
+    _this->_impl_.privatekey_.Set(from._internal_privatekey(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.id_ = from._impl_.id_;
+  // @@protoc_insertion_point(copy_constructor:proto.PreKeyRecordStructure)
+}
+
+inline void PreKeyRecordStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}
+    , decltype(_impl_.id_){0u}
+  };
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PreKeyRecordStructure::~PreKeyRecordStructure() {
+  // @@protoc_insertion_point(destructor:proto.PreKeyRecordStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PreKeyRecordStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.publickey_.Destroy();
+  _impl_.privatekey_.Destroy();
+}
+
+void PreKeyRecordStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PreKeyRecordStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.PreKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.publickey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.privatekey_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.id_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_id(&has_bits);
+          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes publicKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_publickey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes privateKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_privatekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PreKeyRecordStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.PreKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 id = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
+  }
+
+  // optional bytes publicKey = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_publickey(), target);
+  }
+
+  // optional bytes privateKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_privatekey(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.PreKeyRecordStructure)
+  return target;
+}
+
+size_t PreKeyRecordStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.PreKeyRecordStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes publicKey = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_publickey());
+    }
+
+    // optional bytes privateKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_privatekey());
+    }
+
+    // optional uint32 id = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreKeyRecordStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PreKeyRecordStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreKeyRecordStructure::GetClassData() const { return &_class_data_; }
+
+
+void PreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PreKeyRecordStructure*>(&to_msg);
+  auto& from = static_cast<const PreKeyRecordStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.PreKeyRecordStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_publickey(from._internal_publickey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_privatekey(from._internal_privatekey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.id_ = from._impl_.id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PreKeyRecordStructure::CopyFrom(const PreKeyRecordStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.PreKeyRecordStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PreKeyRecordStructure::IsInitialized() const {
+  return true;
+}
+
+void PreKeyRecordStructure::InternalSwap(PreKeyRecordStructure* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.publickey_, lhs_arena,
+      &other->_impl_.publickey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.privatekey_, lhs_arena,
+      &other->_impl_.privatekey_, rhs_arena
+  );
+  swap(_impl_.id_, other->_impl_.id_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PreKeyRecordStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[159]);
+}
+
+// ===================================================================
+
+class Pushname::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Pushname>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_pushname(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+Pushname::Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Pushname)
+}
+Pushname::Pushname(const Pushname& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Pushname* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.pushname_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pushname()) {
+    _this->_impl_.pushname_.Set(from._internal_pushname(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.Pushname)
+}
+
+inline void Pushname::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.pushname_){}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Pushname::~Pushname() {
+  // @@protoc_insertion_point(destructor:proto.Pushname)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Pushname::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+  _impl_.pushname_.Destroy();
+}
+
+void Pushname::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Pushname::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Pushname)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.pushname_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Pushname::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Pushname.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pushname = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_pushname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Pushname.pushname");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Pushname::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Pushname)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Pushname.id");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  // optional string pushname = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pushname().data(), static_cast<int>(this->_internal_pushname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Pushname.pushname");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_pushname(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Pushname)
+  return target;
+}
+
+size_t Pushname::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Pushname)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string id = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional string pushname = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pushname());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Pushname::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Pushname::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Pushname::GetClassData() const { return &_class_data_; }
+
+
+void Pushname::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Pushname*>(&to_msg);
+  auto& from = static_cast<const Pushname&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Pushname)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_pushname(from._internal_pushname());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Pushname::CopyFrom(const Pushname& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Pushname)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Pushname::IsInitialized() const {
+  return true;
+}
+
+void Pushname::InternalSwap(Pushname* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pushname_, lhs_arena,
+      &other->_impl_.pushname_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Pushname::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[160]);
+}
+
+// ===================================================================
+
+class Reaction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Reaction>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const Reaction* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_text(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_groupingkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_sendertimestampms(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_unread(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+const ::proto::MessageKey&
+Reaction::_Internal::key(const Reaction* msg) {
+  return *msg->_impl_.key_;
+}
+Reaction::Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.Reaction)
+}
+Reaction::Reaction(const Reaction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Reaction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.groupingkey_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.sendertimestampms_){}
+    , decltype(_impl_.unread_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_text()) {
+    _this->_impl_.text_.Set(from._internal_text(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.groupingkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_groupingkey()) {
+    _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  ::memcpy(&_impl_.sendertimestampms_, &from._impl_.sendertimestampms_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.unread_) -
+    reinterpret_cast<char*>(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_));
+  // @@protoc_insertion_point(copy_constructor:proto.Reaction)
+}
+
+inline void Reaction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.text_){}
+    , decltype(_impl_.groupingkey_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.sendertimestampms_){int64_t{0}}
+    , decltype(_impl_.unread_){false}
+  };
+  _impl_.text_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.text_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.groupingkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Reaction::~Reaction() {
+  // @@protoc_insertion_point(destructor:proto.Reaction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Reaction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.text_.Destroy();
+  _impl_.groupingkey_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void Reaction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Reaction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.Reaction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.text_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.groupingkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000018u) {
+    ::memset(&_impl_.sendertimestampms_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.unread_) -
+        reinterpret_cast<char*>(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Reaction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string text = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_text();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Reaction.text");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string groupingKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_groupingkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.Reaction.groupingKey");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 senderTimestampMs = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_sendertimestampms(&has_bits);
+          _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool unread = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_unread(&has_bits);
+          _impl_.unread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Reaction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.Reaction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string text = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Reaction.text");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_text(), target);
+  }
+
+  // optional string groupingKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_groupingkey().data(), static_cast<int>(this->_internal_groupingkey().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.Reaction.groupingKey");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_groupingkey(), target);
+  }
+
+  // optional int64 senderTimestampMs = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target);
+  }
+
+  // optional bool unread = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_unread(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.Reaction)
+  return target;
+}
+
+size_t Reaction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.Reaction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string text = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_text());
+    }
+
+    // optional string groupingKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_groupingkey());
+    }
+
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional int64 senderTimestampMs = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms());
+    }
+
+    // optional bool unread = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Reaction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Reaction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Reaction::GetClassData() const { return &_class_data_; }
+
+
+void Reaction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Reaction*>(&to_msg);
+  auto& from = static_cast<const Reaction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.Reaction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_text(from._internal_text());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_groupingkey(from._internal_groupingkey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.unread_ = from._impl_.unread_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Reaction::CopyFrom(const Reaction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.Reaction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Reaction::IsInitialized() const {
+  return true;
+}
+
+void Reaction::InternalSwap(Reaction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.text_, lhs_arena,
+      &other->_impl_.text_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.groupingkey_, lhs_arena,
+      &other->_impl_.groupingkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Reaction, _impl_.unread_)
+      + sizeof(Reaction::_impl_.unread_)
+      - PROTOBUF_FIELD_OFFSET(Reaction, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Reaction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[161]);
+}
+
+// ===================================================================
+
+class RecentEmojiWeight::_Internal {
+ public:
+  using HasBits = decltype(std::declval<RecentEmojiWeight>()._impl_._has_bits_);
+  static void set_has_emoji(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_weight(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+RecentEmojiWeight::RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.RecentEmojiWeight)
+}
+RecentEmojiWeight::RecentEmojiWeight(const RecentEmojiWeight& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  RecentEmojiWeight* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.emoji_){}
+    , decltype(_impl_.weight_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.emoji_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.emoji_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_emoji()) {
+    _this->_impl_.emoji_.Set(from._internal_emoji(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.weight_ = from._impl_.weight_;
+  // @@protoc_insertion_point(copy_constructor:proto.RecentEmojiWeight)
+}
+
+inline void RecentEmojiWeight::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.emoji_){}
+    , decltype(_impl_.weight_){0}
+  };
+  _impl_.emoji_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.emoji_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+RecentEmojiWeight::~RecentEmojiWeight() {
+  // @@protoc_insertion_point(destructor:proto.RecentEmojiWeight)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void RecentEmojiWeight::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.emoji_.Destroy();
+}
+
+void RecentEmojiWeight::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void RecentEmojiWeight::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.RecentEmojiWeight)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.emoji_.ClearNonDefaultToEmpty();
+  }
+  _impl_.weight_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RecentEmojiWeight::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string emoji = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_emoji();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.RecentEmojiWeight.emoji");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float weight = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+          _Internal::set_has_weight(&has_bits);
+          _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RecentEmojiWeight::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.RecentEmojiWeight)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string emoji = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_emoji().data(), static_cast<int>(this->_internal_emoji().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.RecentEmojiWeight.emoji");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_emoji(), target);
+  }
+
+  // optional float weight = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_weight(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.RecentEmojiWeight)
+  return target;
+}
+
+size_t RecentEmojiWeight::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.RecentEmojiWeight)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string emoji = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_emoji());
+    }
+
+    // optional float weight = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecentEmojiWeight::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    RecentEmojiWeight::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecentEmojiWeight::GetClassData() const { return &_class_data_; }
+
+
+void RecentEmojiWeight::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<RecentEmojiWeight*>(&to_msg);
+  auto& from = static_cast<const RecentEmojiWeight&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecentEmojiWeight)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_emoji(from._internal_emoji());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.weight_ = from._impl_.weight_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RecentEmojiWeight::CopyFrom(const RecentEmojiWeight& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecentEmojiWeight)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RecentEmojiWeight::IsInitialized() const {
+  return true;
+}
+
+void RecentEmojiWeight::InternalSwap(RecentEmojiWeight* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.emoji_, lhs_arena,
+      &other->_impl_.emoji_, rhs_arena
+  );
+  swap(_impl_.weight_, other->_impl_.weight_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RecentEmojiWeight::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[162]);
+}
+
+// ===================================================================
+
+class RecordStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<RecordStructure>()._impl_._has_bits_);
+  static const ::proto::SessionStructure& currentsession(const RecordStructure* msg);
+  static void set_has_currentsession(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SessionStructure&
+RecordStructure::_Internal::currentsession(const RecordStructure* msg) {
+  return *msg->_impl_.currentsession_;
+}
+RecordStructure::RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.RecordStructure)
+}
+RecordStructure::RecordStructure(const RecordStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  RecordStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.previoussessions_){from._impl_.previoussessions_}
+    , decltype(_impl_.currentsession_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_currentsession()) {
+    _this->_impl_.currentsession_ = new ::proto::SessionStructure(*from._impl_.currentsession_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.RecordStructure)
+}
+
+inline void RecordStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.previoussessions_){arena}
+    , decltype(_impl_.currentsession_){nullptr}
+  };
+}
+
+RecordStructure::~RecordStructure() {
+  // @@protoc_insertion_point(destructor:proto.RecordStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void RecordStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.previoussessions_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.currentsession_;
+}
+
+void RecordStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void RecordStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.RecordStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.previoussessions_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.currentsession_ != nullptr);
+    _impl_.currentsession_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SessionStructure currentSession = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_currentsession(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.SessionStructure previousSessions = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_previoussessions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RecordStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.RecordStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SessionStructure currentSession = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::currentsession(this),
+        _Internal::currentsession(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.SessionStructure previousSessions = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_previoussessions_size()); i < n; i++) {
+    const auto& repfield = this->_internal_previoussessions(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.RecordStructure)
+  return target;
+}
+
+size_t RecordStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.RecordStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SessionStructure previousSessions = 2;
+  total_size += 1UL * this->_internal_previoussessions_size();
+  for (const auto& msg : this->_impl_.previoussessions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional .proto.SessionStructure currentSession = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.currentsession_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecordStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    RecordStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecordStructure::GetClassData() const { return &_class_data_; }
+
+
+void RecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<RecordStructure*>(&to_msg);
+  auto& from = static_cast<const RecordStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecordStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.previoussessions_.MergeFrom(from._impl_.previoussessions_);
+  if (from._internal_has_currentsession()) {
+    _this->_internal_mutable_currentsession()->::proto::SessionStructure::MergeFrom(
+        from._internal_currentsession());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RecordStructure::CopyFrom(const RecordStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecordStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RecordStructure::IsInitialized() const {
+  return true;
+}
+
+void RecordStructure::InternalSwap(RecordStructure* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.previoussessions_.InternalSwap(&other->_impl_.previoussessions_);
+  swap(_impl_.currentsession_, other->_impl_.currentsession_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RecordStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[163]);
+}
+
+// ===================================================================
+
+class SenderChainKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SenderChainKey>()._impl_._has_bits_);
+  static void set_has_iteration(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_seed(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SenderChainKey::SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SenderChainKey)
+}
+SenderChainKey::SenderChainKey(const SenderChainKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SenderChainKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.seed_){}
+    , decltype(_impl_.iteration_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.seed_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_seed()) {
+    _this->_impl_.seed_.Set(from._internal_seed(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.iteration_ = from._impl_.iteration_;
+  // @@protoc_insertion_point(copy_constructor:proto.SenderChainKey)
+}
+
+inline void SenderChainKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.seed_){}
+    , decltype(_impl_.iteration_){0u}
+  };
+  _impl_.seed_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SenderChainKey::~SenderChainKey() {
+  // @@protoc_insertion_point(destructor:proto.SenderChainKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SenderChainKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.seed_.Destroy();
+}
+
+void SenderChainKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SenderChainKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SenderChainKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.seed_.ClearNonDefaultToEmpty();
+  }
+  _impl_.iteration_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SenderChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 iteration = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_iteration(&has_bits);
+          _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes seed = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_seed();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SenderChainKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SenderChainKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 iteration = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target);
+  }
+
+  // optional bytes seed = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_seed(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SenderChainKey)
+  return target;
+}
+
+size_t SenderChainKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SenderChainKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes seed = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_seed());
+    }
+
+    // optional uint32 iteration = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderChainKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SenderChainKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderChainKey::GetClassData() const { return &_class_data_; }
+
+
+void SenderChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SenderChainKey*>(&to_msg);
+  auto& from = static_cast<const SenderChainKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderChainKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_seed(from._internal_seed());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.iteration_ = from._impl_.iteration_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SenderChainKey::CopyFrom(const SenderChainKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderChainKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SenderChainKey::IsInitialized() const {
+  return true;
+}
+
+void SenderChainKey::InternalSwap(SenderChainKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.seed_, lhs_arena,
+      &other->_impl_.seed_, rhs_arena
+  );
+  swap(_impl_.iteration_, other->_impl_.iteration_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SenderChainKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[164]);
+}
+
+// ===================================================================
+
+class SenderKeyRecordStructure::_Internal {
+ public:
+};
+
+SenderKeyRecordStructure::SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SenderKeyRecordStructure)
+}
+SenderKeyRecordStructure::SenderKeyRecordStructure(const SenderKeyRecordStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SenderKeyRecordStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.senderkeystates_){from._impl_.senderkeystates_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.SenderKeyRecordStructure)
+}
+
+inline void SenderKeyRecordStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.senderkeystates_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+SenderKeyRecordStructure::~SenderKeyRecordStructure() {
+  // @@protoc_insertion_point(destructor:proto.SenderKeyRecordStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SenderKeyRecordStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.senderkeystates_.~RepeatedPtrField();
+}
+
+void SenderKeyRecordStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SenderKeyRecordStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SenderKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.senderkeystates_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SenderKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_senderkeystates(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SenderKeyRecordStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_senderkeystates_size()); i < n; i++) {
+    const auto& repfield = this->_internal_senderkeystates(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SenderKeyRecordStructure)
+  return target;
+}
+
+size_t SenderKeyRecordStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyRecordStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
+  total_size += 1UL * this->_internal_senderkeystates_size();
+  for (const auto& msg : this->_impl_.senderkeystates_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyRecordStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SenderKeyRecordStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyRecordStructure::GetClassData() const { return &_class_data_; }
+
+
+void SenderKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SenderKeyRecordStructure*>(&to_msg);
+  auto& from = static_cast<const SenderKeyRecordStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyRecordStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.senderkeystates_.MergeFrom(from._impl_.senderkeystates_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SenderKeyRecordStructure::CopyFrom(const SenderKeyRecordStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyRecordStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SenderKeyRecordStructure::IsInitialized() const {
+  return true;
+}
+
+void SenderKeyRecordStructure::InternalSwap(SenderKeyRecordStructure* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.senderkeystates_.InternalSwap(&other->_impl_.senderkeystates_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyRecordStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[165]);
+}
+
+// ===================================================================
+
+class SenderKeyStateStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SenderKeyStateStructure>()._impl_._has_bits_);
+  static void set_has_senderkeyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::SenderChainKey& senderchainkey(const SenderKeyStateStructure* msg);
+  static void set_has_senderchainkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::SenderSigningKey& sendersigningkey(const SenderKeyStateStructure* msg);
+  static void set_has_sendersigningkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::SenderChainKey&
+SenderKeyStateStructure::_Internal::senderchainkey(const SenderKeyStateStructure* msg) {
+  return *msg->_impl_.senderchainkey_;
+}
+const ::proto::SenderSigningKey&
+SenderKeyStateStructure::_Internal::sendersigningkey(const SenderKeyStateStructure* msg) {
+  return *msg->_impl_.sendersigningkey_;
+}
+SenderKeyStateStructure::SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SenderKeyStateStructure)
+}
+SenderKeyStateStructure::SenderKeyStateStructure(const SenderKeyStateStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SenderKeyStateStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sendermessagekeys_){from._impl_.sendermessagekeys_}
+    , decltype(_impl_.senderchainkey_){nullptr}
+    , decltype(_impl_.sendersigningkey_){nullptr}
+    , decltype(_impl_.senderkeyid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_senderchainkey()) {
+    _this->_impl_.senderchainkey_ = new ::proto::SenderChainKey(*from._impl_.senderchainkey_);
+  }
+  if (from._internal_has_sendersigningkey()) {
+    _this->_impl_.sendersigningkey_ = new ::proto::SenderSigningKey(*from._impl_.sendersigningkey_);
+  }
+  _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_;
+  // @@protoc_insertion_point(copy_constructor:proto.SenderKeyStateStructure)
+}
+
+inline void SenderKeyStateStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sendermessagekeys_){arena}
+    , decltype(_impl_.senderchainkey_){nullptr}
+    , decltype(_impl_.sendersigningkey_){nullptr}
+    , decltype(_impl_.senderkeyid_){0u}
+  };
+}
+
+SenderKeyStateStructure::~SenderKeyStateStructure() {
+  // @@protoc_insertion_point(destructor:proto.SenderKeyStateStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SenderKeyStateStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.sendermessagekeys_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.senderchainkey_;
+  if (this != internal_default_instance()) delete _impl_.sendersigningkey_;
+}
+
+void SenderKeyStateStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SenderKeyStateStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SenderKeyStateStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.sendermessagekeys_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.senderchainkey_ != nullptr);
+      _impl_.senderchainkey_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.sendersigningkey_ != nullptr);
+      _impl_.sendersigningkey_->Clear();
+    }
+  }
+  _impl_.senderkeyid_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SenderKeyStateStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 senderKeyId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_senderkeyid(&has_bits);
+          _impl_.senderkeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SenderChainKey senderChainKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_senderchainkey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SenderSigningKey senderSigningKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_sendersigningkey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.SenderMessageKey senderMessageKeys = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_sendermessagekeys(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SenderKeyStateStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyStateStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 senderKeyId = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_senderkeyid(), target);
+  }
+
+  // optional .proto.SenderChainKey senderChainKey = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::senderchainkey(this),
+        _Internal::senderchainkey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SenderSigningKey senderSigningKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::sendersigningkey(this),
+        _Internal::sendersigningkey(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.SenderMessageKey senderMessageKeys = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_sendermessagekeys_size()); i < n; i++) {
+    const auto& repfield = this->_internal_sendermessagekeys(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SenderKeyStateStructure)
+  return target;
+}
+
+size_t SenderKeyStateStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyStateStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SenderMessageKey senderMessageKeys = 4;
+  total_size += 1UL * this->_internal_sendermessagekeys_size();
+  for (const auto& msg : this->_impl_.sendermessagekeys_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.SenderChainKey senderChainKey = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.senderchainkey_);
+    }
+
+    // optional .proto.SenderSigningKey senderSigningKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.sendersigningkey_);
+    }
+
+    // optional uint32 senderKeyId = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_senderkeyid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyStateStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SenderKeyStateStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyStateStructure::GetClassData() const { return &_class_data_; }
+
+
+void SenderKeyStateStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SenderKeyStateStructure*>(&to_msg);
+  auto& from = static_cast<const SenderKeyStateStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyStateStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.sendermessagekeys_.MergeFrom(from._impl_.sendermessagekeys_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_senderchainkey()->::proto::SenderChainKey::MergeFrom(
+          from._internal_senderchainkey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_sendersigningkey()->::proto::SenderSigningKey::MergeFrom(
+          from._internal_sendersigningkey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SenderKeyStateStructure::CopyFrom(const SenderKeyStateStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyStateStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SenderKeyStateStructure::IsInitialized() const {
+  return true;
+}
+
+void SenderKeyStateStructure::InternalSwap(SenderKeyStateStructure* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.sendermessagekeys_.InternalSwap(&other->_impl_.sendermessagekeys_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderkeyid_)
+      + sizeof(SenderKeyStateStructure::_impl_.senderkeyid_)
+      - PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderchainkey_)>(
+          reinterpret_cast<char*>(&_impl_.senderchainkey_),
+          reinterpret_cast<char*>(&other->_impl_.senderchainkey_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyStateStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[166]);
+}
+
+// ===================================================================
+
+class SenderMessageKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SenderMessageKey>()._impl_._has_bits_);
+  static void set_has_iteration(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_seed(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SenderMessageKey::SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SenderMessageKey)
+}
+SenderMessageKey::SenderMessageKey(const SenderMessageKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SenderMessageKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.seed_){}
+    , decltype(_impl_.iteration_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.seed_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_seed()) {
+    _this->_impl_.seed_.Set(from._internal_seed(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.iteration_ = from._impl_.iteration_;
+  // @@protoc_insertion_point(copy_constructor:proto.SenderMessageKey)
+}
+
+inline void SenderMessageKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.seed_){}
+    , decltype(_impl_.iteration_){0u}
+  };
+  _impl_.seed_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SenderMessageKey::~SenderMessageKey() {
+  // @@protoc_insertion_point(destructor:proto.SenderMessageKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SenderMessageKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.seed_.Destroy();
+}
+
+void SenderMessageKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SenderMessageKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SenderMessageKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.seed_.ClearNonDefaultToEmpty();
+  }
+  _impl_.iteration_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SenderMessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 iteration = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_iteration(&has_bits);
+          _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes seed = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_seed();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SenderMessageKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SenderMessageKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 iteration = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target);
+  }
+
+  // optional bytes seed = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_seed(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SenderMessageKey)
+  return target;
+}
+
+size_t SenderMessageKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SenderMessageKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes seed = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_seed());
+    }
+
+    // optional uint32 iteration = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderMessageKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SenderMessageKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderMessageKey::GetClassData() const { return &_class_data_; }
+
+
+void SenderMessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SenderMessageKey*>(&to_msg);
+  auto& from = static_cast<const SenderMessageKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderMessageKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_seed(from._internal_seed());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.iteration_ = from._impl_.iteration_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SenderMessageKey::CopyFrom(const SenderMessageKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderMessageKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SenderMessageKey::IsInitialized() const {
+  return true;
+}
+
+void SenderMessageKey::InternalSwap(SenderMessageKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.seed_, lhs_arena,
+      &other->_impl_.seed_, rhs_arena
+  );
+  swap(_impl_.iteration_, other->_impl_.iteration_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SenderMessageKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[167]);
+}
+
+// ===================================================================
+
+class SenderSigningKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SenderSigningKey>()._impl_._has_bits_);
+  static void set_has_public_(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_private_(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+SenderSigningKey::SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SenderSigningKey)
+}
+SenderSigningKey::SenderSigningKey(const SenderSigningKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SenderSigningKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.public__){}
+    , decltype(_impl_.private__){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.public__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.public__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_public_()) {
+    _this->_impl_.public__.Set(from._internal_public_(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.private__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.private__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_private_()) {
+    _this->_impl_.private__.Set(from._internal_private_(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SenderSigningKey)
+}
+
+inline void SenderSigningKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.public__){}
+    , decltype(_impl_.private__){}
+  };
+  _impl_.public__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.public__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.private__.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.private__.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SenderSigningKey::~SenderSigningKey() {
+  // @@protoc_insertion_point(destructor:proto.SenderSigningKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SenderSigningKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.public__.Destroy();
+  _impl_.private__.Destroy();
+}
+
+void SenderSigningKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SenderSigningKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SenderSigningKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.public__.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.private__.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SenderSigningKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes public = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_public_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes private = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_private_();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SenderSigningKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SenderSigningKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes public = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_public_(), target);
+  }
+
+  // optional bytes private = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_private_(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SenderSigningKey)
+  return target;
+}
+
+size_t SenderSigningKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SenderSigningKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes public = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_public_());
+    }
+
+    // optional bytes private = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_private_());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderSigningKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SenderSigningKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderSigningKey::GetClassData() const { return &_class_data_; }
+
+
+void SenderSigningKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SenderSigningKey*>(&to_msg);
+  auto& from = static_cast<const SenderSigningKey&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderSigningKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_public_(from._internal_public_());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_private_(from._internal_private_());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SenderSigningKey::CopyFrom(const SenderSigningKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderSigningKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SenderSigningKey::IsInitialized() const {
+  return true;
+}
+
+void SenderSigningKey::InternalSwap(SenderSigningKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.public__, lhs_arena,
+      &other->_impl_.public__, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.private__, lhs_arena,
+      &other->_impl_.private__, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SenderSigningKey::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[168]);
+}
+
+// ===================================================================
+
+class ServerErrorReceipt::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ServerErrorReceipt>()._impl_._has_bits_);
+  static void set_has_stanzaid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ServerErrorReceipt::ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.ServerErrorReceipt)
+}
+ServerErrorReceipt::ServerErrorReceipt(const ServerErrorReceipt& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ServerErrorReceipt* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.stanzaid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_stanzaid()) {
+    _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.ServerErrorReceipt)
+}
+
+inline void ServerErrorReceipt::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.stanzaid_){}
+  };
+  _impl_.stanzaid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ServerErrorReceipt::~ServerErrorReceipt() {
+  // @@protoc_insertion_point(destructor:proto.ServerErrorReceipt)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ServerErrorReceipt::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.stanzaid_.Destroy();
+}
+
+void ServerErrorReceipt::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ServerErrorReceipt::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ServerErrorReceipt)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.stanzaid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ServerErrorReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string stanzaId = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_stanzaid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.ServerErrorReceipt.stanzaId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ServerErrorReceipt::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.ServerErrorReceipt)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string stanzaId = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_stanzaid().data(), static_cast<int>(this->_internal_stanzaid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.ServerErrorReceipt.stanzaId");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_stanzaid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.ServerErrorReceipt)
+  return target;
+}
+
+size_t ServerErrorReceipt::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ServerErrorReceipt)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string stanzaId = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_stanzaid());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ServerErrorReceipt::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ServerErrorReceipt::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ServerErrorReceipt::GetClassData() const { return &_class_data_; }
+
+
+void ServerErrorReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ServerErrorReceipt*>(&to_msg);
+  auto& from = static_cast<const ServerErrorReceipt&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.ServerErrorReceipt)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_stanzaid()) {
+    _this->_internal_set_stanzaid(from._internal_stanzaid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ServerErrorReceipt::CopyFrom(const ServerErrorReceipt& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ServerErrorReceipt)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServerErrorReceipt::IsInitialized() const {
+  return true;
+}
+
+void ServerErrorReceipt::InternalSwap(ServerErrorReceipt* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.stanzaid_, lhs_arena,
+      &other->_impl_.stanzaid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ServerErrorReceipt::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[169]);
+}
+
+// ===================================================================
+
+class SessionStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SessionStructure>()._impl_._has_bits_);
+  static void set_has_sessionversion(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_localidentitypublic(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_remoteidentitypublic(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_rootkey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_previouscounter(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::Chain& senderchain(const SessionStructure* msg);
+  static void set_has_senderchain(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::PendingKeyExchange& pendingkeyexchange(const SessionStructure* msg);
+  static void set_has_pendingkeyexchange(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::PendingPreKey& pendingprekey(const SessionStructure* msg);
+  static void set_has_pendingprekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_remoteregistrationid(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_localregistrationid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_needsrefresh(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_alicebasekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::Chain&
+SessionStructure::_Internal::senderchain(const SessionStructure* msg) {
+  return *msg->_impl_.senderchain_;
+}
+const ::proto::PendingKeyExchange&
+SessionStructure::_Internal::pendingkeyexchange(const SessionStructure* msg) {
+  return *msg->_impl_.pendingkeyexchange_;
+}
+const ::proto::PendingPreKey&
+SessionStructure::_Internal::pendingprekey(const SessionStructure* msg) {
+  return *msg->_impl_.pendingprekey_;
+}
+SessionStructure::SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SessionStructure)
+}
+SessionStructure::SessionStructure(const SessionStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SessionStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.receiverchains_){from._impl_.receiverchains_}
+    , decltype(_impl_.localidentitypublic_){}
+    , decltype(_impl_.remoteidentitypublic_){}
+    , decltype(_impl_.rootkey_){}
+    , decltype(_impl_.alicebasekey_){}
+    , decltype(_impl_.senderchain_){nullptr}
+    , decltype(_impl_.pendingkeyexchange_){nullptr}
+    , decltype(_impl_.pendingprekey_){nullptr}
+    , decltype(_impl_.sessionversion_){}
+    , decltype(_impl_.previouscounter_){}
+    , decltype(_impl_.remoteregistrationid_){}
+    , decltype(_impl_.localregistrationid_){}
+    , decltype(_impl_.needsrefresh_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.localidentitypublic_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_localidentitypublic()) {
+    _this->_impl_.localidentitypublic_.Set(from._internal_localidentitypublic(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.remoteidentitypublic_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_remoteidentitypublic()) {
+    _this->_impl_.remoteidentitypublic_.Set(from._internal_remoteidentitypublic(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.rootkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rootkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_rootkey()) {
+    _this->_impl_.rootkey_.Set(from._internal_rootkey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.alicebasekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_alicebasekey()) {
+    _this->_impl_.alicebasekey_.Set(from._internal_alicebasekey(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_senderchain()) {
+    _this->_impl_.senderchain_ = new ::proto::Chain(*from._impl_.senderchain_);
+  }
+  if (from._internal_has_pendingkeyexchange()) {
+    _this->_impl_.pendingkeyexchange_ = new ::proto::PendingKeyExchange(*from._impl_.pendingkeyexchange_);
+  }
+  if (from._internal_has_pendingprekey()) {
+    _this->_impl_.pendingprekey_ = new ::proto::PendingPreKey(*from._impl_.pendingprekey_);
+  }
+  ::memcpy(&_impl_.sessionversion_, &from._impl_.sessionversion_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.needsrefresh_) -
+    reinterpret_cast<char*>(&_impl_.sessionversion_)) + sizeof(_impl_.needsrefresh_));
+  // @@protoc_insertion_point(copy_constructor:proto.SessionStructure)
+}
+
+inline void SessionStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.receiverchains_){arena}
+    , decltype(_impl_.localidentitypublic_){}
+    , decltype(_impl_.remoteidentitypublic_){}
+    , decltype(_impl_.rootkey_){}
+    , decltype(_impl_.alicebasekey_){}
+    , decltype(_impl_.senderchain_){nullptr}
+    , decltype(_impl_.pendingkeyexchange_){nullptr}
+    , decltype(_impl_.pendingprekey_){nullptr}
+    , decltype(_impl_.sessionversion_){0u}
+    , decltype(_impl_.previouscounter_){0u}
+    , decltype(_impl_.remoteregistrationid_){0u}
+    , decltype(_impl_.localregistrationid_){0u}
+    , decltype(_impl_.needsrefresh_){false}
+  };
+  _impl_.localidentitypublic_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.remoteidentitypublic_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.rootkey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rootkey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.alicebasekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SessionStructure::~SessionStructure() {
+  // @@protoc_insertion_point(destructor:proto.SessionStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SessionStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.receiverchains_.~RepeatedPtrField();
+  _impl_.localidentitypublic_.Destroy();
+  _impl_.remoteidentitypublic_.Destroy();
+  _impl_.rootkey_.Destroy();
+  _impl_.alicebasekey_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.senderchain_;
+  if (this != internal_default_instance()) delete _impl_.pendingkeyexchange_;
+  if (this != internal_default_instance()) delete _impl_.pendingprekey_;
+}
+
+void SessionStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SessionStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SessionStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.receiverchains_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.localidentitypublic_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.remoteidentitypublic_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.rootkey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.alicebasekey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.senderchain_ != nullptr);
+      _impl_.senderchain_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.pendingkeyexchange_ != nullptr);
+      _impl_.pendingkeyexchange_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.pendingprekey_ != nullptr);
+      _impl_.pendingprekey_->Clear();
+    }
+  }
+  _impl_.sessionversion_ = 0u;
+  if (cached_has_bits & 0x00000f00u) {
+    ::memset(&_impl_.previouscounter_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.needsrefresh_) -
+        reinterpret_cast<char*>(&_impl_.previouscounter_)) + sizeof(_impl_.needsrefresh_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SessionStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 sessionVersion = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_sessionversion(&has_bits);
+          _impl_.sessionversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes localIdentityPublic = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_localidentitypublic();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes remoteIdentityPublic = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_remoteidentitypublic();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes rootKey = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_rootkey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 previousCounter = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_previouscounter(&has_bits);
+          _impl_.previouscounter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Chain senderChain = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_senderchain(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Chain receiverChains = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_receiverchains(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PendingKeyExchange pendingKeyExchange = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pendingkeyexchange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PendingPreKey pendingPreKey = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pendingprekey(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 remoteRegistrationId = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_remoteregistrationid(&has_bits);
+          _impl_.remoteregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 localRegistrationId = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_localregistrationid(&has_bits);
+          _impl_.localregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool needsRefresh = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_needsrefresh(&has_bits);
+          _impl_.needsrefresh_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes aliceBaseKey = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_alicebasekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SessionStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SessionStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 sessionVersion = 1;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sessionversion(), target);
+  }
+
+  // optional bytes localIdentityPublic = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_localidentitypublic(), target);
+  }
+
+  // optional bytes remoteIdentityPublic = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_remoteidentitypublic(), target);
+  }
+
+  // optional bytes rootKey = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_rootkey(), target);
+  }
+
+  // optional uint32 previousCounter = 5;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_previouscounter(), target);
+  }
+
+  // optional .proto.Chain senderChain = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::senderchain(this),
+        _Internal::senderchain(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.Chain receiverChains = 7;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_receiverchains_size()); i < n; i++) {
+    const auto& repfield = this->_internal_receiverchains(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PendingKeyExchange pendingKeyExchange = 8;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::pendingkeyexchange(this),
+        _Internal::pendingkeyexchange(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PendingPreKey pendingPreKey = 9;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::pendingprekey(this),
+        _Internal::pendingprekey(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 remoteRegistrationId = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_remoteregistrationid(), target);
+  }
+
+  // optional uint32 localRegistrationId = 11;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_localregistrationid(), target);
+  }
+
+  // optional bool needsRefresh = 12;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_needsrefresh(), target);
+  }
+
+  // optional bytes aliceBaseKey = 13;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        13, this->_internal_alicebasekey(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SessionStructure)
+  return target;
+}
+
+size_t SessionStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SessionStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.Chain receiverChains = 7;
+  total_size += 1UL * this->_internal_receiverchains_size();
+  for (const auto& msg : this->_impl_.receiverchains_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional bytes localIdentityPublic = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_localidentitypublic());
+    }
+
+    // optional bytes remoteIdentityPublic = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_remoteidentitypublic());
+    }
+
+    // optional bytes rootKey = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_rootkey());
+    }
+
+    // optional bytes aliceBaseKey = 13;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_alicebasekey());
+    }
+
+    // optional .proto.Chain senderChain = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.senderchain_);
+    }
+
+    // optional .proto.PendingKeyExchange pendingKeyExchange = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pendingkeyexchange_);
+    }
+
+    // optional .proto.PendingPreKey pendingPreKey = 9;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pendingprekey_);
+    }
+
+    // optional uint32 sessionVersion = 1;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sessionversion());
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional uint32 previousCounter = 5;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_previouscounter());
+    }
+
+    // optional uint32 remoteRegistrationId = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_remoteregistrationid());
+    }
+
+    // optional uint32 localRegistrationId = 11;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_localregistrationid());
+    }
+
+    // optional bool needsRefresh = 12;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SessionStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SessionStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SessionStructure::GetClassData() const { return &_class_data_; }
+
+
+void SessionStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SessionStructure*>(&to_msg);
+  auto& from = static_cast<const SessionStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SessionStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.receiverchains_.MergeFrom(from._impl_.receiverchains_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_localidentitypublic(from._internal_localidentitypublic());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_remoteidentitypublic(from._internal_remoteidentitypublic());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_rootkey(from._internal_rootkey());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_alicebasekey(from._internal_alicebasekey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_senderchain()->::proto::Chain::MergeFrom(
+          from._internal_senderchain());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_pendingkeyexchange()->::proto::PendingKeyExchange::MergeFrom(
+          from._internal_pendingkeyexchange());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_pendingprekey()->::proto::PendingPreKey::MergeFrom(
+          from._internal_pendingprekey());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.sessionversion_ = from._impl_.sessionversion_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.previouscounter_ = from._impl_.previouscounter_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.remoteregistrationid_ = from._impl_.remoteregistrationid_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.localregistrationid_ = from._impl_.localregistrationid_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.needsrefresh_ = from._impl_.needsrefresh_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SessionStructure::CopyFrom(const SessionStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SessionStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SessionStructure::IsInitialized() const {
+  return true;
+}
+
+void SessionStructure::InternalSwap(SessionStructure* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.receiverchains_.InternalSwap(&other->_impl_.receiverchains_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.localidentitypublic_, lhs_arena,
+      &other->_impl_.localidentitypublic_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.remoteidentitypublic_, lhs_arena,
+      &other->_impl_.remoteidentitypublic_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.rootkey_, lhs_arena,
+      &other->_impl_.rootkey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.alicebasekey_, lhs_arena,
+      &other->_impl_.alicebasekey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.needsrefresh_)
+      + sizeof(SessionStructure::_impl_.needsrefresh_)
+      - PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.senderchain_)>(
+          reinterpret_cast<char*>(&_impl_.senderchain_),
+          reinterpret_cast<char*>(&other->_impl_.senderchain_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SessionStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[170]);
+}
+
+// ===================================================================
+
+class SignedPreKeyRecordStructure::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SignedPreKeyRecordStructure>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_publickey(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_privatekey(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SignedPreKeyRecordStructure)
+}
+SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SignedPreKeyRecordStructure* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}
+    , decltype(_impl_.signature_){}
+    , decltype(_impl_.timestamp_){}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_publickey()) {
+    _this->_impl_.publickey_.Set(from._internal_publickey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_privatekey()) {
+    _this->_impl_.privatekey_.Set(from._internal_privatekey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_.Set(from._internal_signature(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.id_) -
+    reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.id_));
+  // @@protoc_insertion_point(copy_constructor:proto.SignedPreKeyRecordStructure)
+}
+
+inline void SignedPreKeyRecordStructure::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.publickey_){}
+    , decltype(_impl_.privatekey_){}
+    , decltype(_impl_.signature_){}
+    , decltype(_impl_.timestamp_){uint64_t{0u}}
+    , decltype(_impl_.id_){0u}
+  };
+  _impl_.publickey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.privatekey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SignedPreKeyRecordStructure::~SignedPreKeyRecordStructure() {
+  // @@protoc_insertion_point(destructor:proto.SignedPreKeyRecordStructure)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SignedPreKeyRecordStructure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.publickey_.Destroy();
+  _impl_.privatekey_.Destroy();
+  _impl_.signature_.Destroy();
+}
+
+void SignedPreKeyRecordStructure::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SignedPreKeyRecordStructure::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SignedPreKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.publickey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.privatekey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.signature_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000018u) {
+    ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.id_) -
+        reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.id_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SignedPreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_id(&has_bits);
+          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes publicKey = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_publickey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes privateKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_privatekey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes signature = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_signature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional fixed64 timestamp = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 41)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
+          ptr += sizeof(uint64_t);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SignedPreKeyRecordStructure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SignedPreKeyRecordStructure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 id = 1;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
+  }
+
+  // optional bytes publicKey = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_publickey(), target);
+  }
+
+  // optional bytes privateKey = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_privatekey(), target);
+  }
+
+  // optional bytes signature = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_signature(), target);
+  }
+
+  // optional fixed64 timestamp = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(5, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SignedPreKeyRecordStructure)
+  return target;
+}
+
+size_t SignedPreKeyRecordStructure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SignedPreKeyRecordStructure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes publicKey = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_publickey());
+    }
+
+    // optional bytes privateKey = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_privatekey());
+    }
+
+    // optional bytes signature = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_signature());
+    }
+
+    // optional fixed64 timestamp = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 8;
+    }
+
+    // optional uint32 id = 1;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SignedPreKeyRecordStructure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SignedPreKeyRecordStructure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SignedPreKeyRecordStructure::GetClassData() const { return &_class_data_; }
+
+
+void SignedPreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SignedPreKeyRecordStructure*>(&to_msg);
+  auto& from = static_cast<const SignedPreKeyRecordStructure&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SignedPreKeyRecordStructure)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_publickey(from._internal_publickey());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_privatekey(from._internal_privatekey());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_signature(from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.id_ = from._impl_.id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SignedPreKeyRecordStructure::CopyFrom(const SignedPreKeyRecordStructure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SignedPreKeyRecordStructure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SignedPreKeyRecordStructure::IsInitialized() const {
+  return true;
+}
+
+void SignedPreKeyRecordStructure::InternalSwap(SignedPreKeyRecordStructure* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.publickey_, lhs_arena,
+      &other->_impl_.publickey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.privatekey_, lhs_arena,
+      &other->_impl_.privatekey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.signature_, lhs_arena,
+      &other->_impl_.signature_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.id_)
+      + sizeof(SignedPreKeyRecordStructure::_impl_.id_)
+      - PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.timestamp_)>(
+          reinterpret_cast<char*>(&_impl_.timestamp_),
+          reinterpret_cast<char*>(&other->_impl_.timestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SignedPreKeyRecordStructure::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[171]);
+}
+
+// ===================================================================
+
+class StatusPSA::_Internal {
+ public:
+  using HasBits = decltype(std::declval<StatusPSA>()._impl_._has_bits_);
+  static void set_has_campaignid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_campaignexpirationtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+StatusPSA::StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.StatusPSA)
+}
+StatusPSA::StatusPSA(const StatusPSA& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  StatusPSA* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.campaignid_){}
+    , decltype(_impl_.campaignexpirationtimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.campaignid_, &from._impl_.campaignid_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.campaignexpirationtimestamp_) -
+    reinterpret_cast<char*>(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.StatusPSA)
+}
+
+inline void StatusPSA::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.campaignid_){uint64_t{0u}}
+    , decltype(_impl_.campaignexpirationtimestamp_){uint64_t{0u}}
+  };
+}
+
+StatusPSA::~StatusPSA() {
+  // @@protoc_insertion_point(destructor:proto.StatusPSA)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void StatusPSA::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void StatusPSA::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void StatusPSA::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.StatusPSA)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.campaignid_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.campaignexpirationtimestamp_) -
+        reinterpret_cast<char*>(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* StatusPSA::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required uint64 campaignId = 44;
+      case 44:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_campaignid(&has_bits);
+          _impl_.campaignid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 campaignExpirationTimestamp = 45;
+      case 45:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          _Internal::set_has_campaignexpirationtimestamp(&has_bits);
+          _impl_.campaignexpirationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* StatusPSA::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.StatusPSA)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required uint64 campaignId = 44;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(44, this->_internal_campaignid(), target);
+  }
+
+  // optional uint64 campaignExpirationTimestamp = 45;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(45, this->_internal_campaignexpirationtimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.StatusPSA)
+  return target;
+}
+
+size_t StatusPSA::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.StatusPSA)
+  size_t total_size = 0;
+
+  // required uint64 campaignId = 44;
+  if (_internal_has_campaignid()) {
+    total_size += 2 +
+      ::_pbi::WireFormatLite::UInt64Size(
+        this->_internal_campaignid());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint64 campaignExpirationTimestamp = 45;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000002u) {
+    total_size += 2 +
+      ::_pbi::WireFormatLite::UInt64Size(
+        this->_internal_campaignexpirationtimestamp());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StatusPSA::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    StatusPSA::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StatusPSA::GetClassData() const { return &_class_data_; }
+
+
+void StatusPSA::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<StatusPSA*>(&to_msg);
+  auto& from = static_cast<const StatusPSA&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.StatusPSA)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.campaignid_ = from._impl_.campaignid_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.campaignexpirationtimestamp_ = from._impl_.campaignexpirationtimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void StatusPSA::CopyFrom(const StatusPSA& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.StatusPSA)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StatusPSA::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void StatusPSA::InternalSwap(StatusPSA* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignexpirationtimestamp_)
+      + sizeof(StatusPSA::_impl_.campaignexpirationtimestamp_)
+      - PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignid_)>(
+          reinterpret_cast<char*>(&_impl_.campaignid_),
+          reinterpret_cast<char*>(&other->_impl_.campaignid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata StatusPSA::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[172]);
+}
+
+// ===================================================================
+
+class StickerMetadata::_Internal {
+ public:
+  using HasBits = decltype(std::declval<StickerMetadata>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_filesha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_weight(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+StickerMetadata::StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.StickerMetadata)
+}
+StickerMetadata::StickerMetadata(const StickerMetadata& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  StickerMetadata* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.weight_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filesha256()) {
+    _this->_impl_.filesha256_.Set(from._internal_filesha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.height_, &from._impl_.height_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.weight_) -
+    reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.weight_));
+  // @@protoc_insertion_point(copy_constructor:proto.StickerMetadata)
+}
+
+inline void StickerMetadata::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.filesha256_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.weight_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.filesha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+StickerMetadata::~StickerMetadata() {
+  // @@protoc_insertion_point(destructor:proto.StickerMetadata)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void StickerMetadata::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.filesha256_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.directpath_.Destroy();
+}
+
+void StickerMetadata::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void StickerMetadata::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.StickerMetadata)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.filesha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    ::memset(&_impl_.height_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.width_) -
+        reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.width_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.filelength_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.weight_) -
+        reinterpret_cast<char*>(&_impl_.filelength_)) + sizeof(_impl_.weight_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* StickerMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileSha256 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_filesha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float weight = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 85)) {
+          _Internal::set_has_weight(&has_bits);
+          _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* StickerMetadata::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.StickerMetadata)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.StickerMetadata.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional bytes fileSha256 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_filesha256(), target);
+  }
+
+  // optional bytes fileEncSha256 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_fileencsha256(), target);
+  }
+
+  // optional bytes mediaKey = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_mediakey(), target);
+  }
+
+  // optional string mimetype = 5;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.StickerMetadata.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_mimetype(), target);
+  }
+
+  // optional uint32 height = 6;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target);
+  }
+
+  // optional uint32 width = 7;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target);
+  }
+
+  // optional string directPath = 8;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.StickerMetadata.directPath");
+    target = stream->WriteStringMaybeAliased(
+        8, this->_internal_directpath(), target);
+  }
+
+  // optional uint64 fileLength = 9;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target);
+  }
+
+  // optional float weight = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(10, this->_internal_weight(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.StickerMetadata)
+  return target;
+}
+
+size_t StickerMetadata::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.StickerMetadata)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional bytes fileSha256 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_filesha256());
+    }
+
+    // optional bytes fileEncSha256 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional bytes mediaKey = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string mimetype = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional string directPath = 8;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional uint32 height = 6;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional uint32 width = 7;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional uint64 fileLength = 9;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+    // optional float weight = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StickerMetadata::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    StickerMetadata::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StickerMetadata::GetClassData() const { return &_class_data_; }
+
+
+void StickerMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<StickerMetadata*>(&to_msg);
+  auto& from = static_cast<const StickerMetadata&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.StickerMetadata)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_filesha256(from._internal_filesha256());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.weight_ = from._impl_.weight_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void StickerMetadata::CopyFrom(const StickerMetadata& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.StickerMetadata)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StickerMetadata::IsInitialized() const {
+  return true;
+}
+
+void StickerMetadata::InternalSwap(StickerMetadata* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filesha256_, lhs_arena,
+      &other->_impl_.filesha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.weight_)
+      + sizeof(StickerMetadata::_impl_.weight_)
+      - PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.height_)>(
+          reinterpret_cast<char*>(&_impl_.height_),
+          reinterpret_cast<char*>(&other->_impl_.height_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata StickerMetadata::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[173]);
+}
+
+// ===================================================================
+
+class SyncActionData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionData>()._impl_._has_bits_);
+  static void set_has_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::SyncActionValue& value(const SyncActionData* msg);
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_padding(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::proto::SyncActionValue&
+SyncActionData::_Internal::value(const SyncActionData* msg) {
+  return *msg->_impl_.value_;
+}
+SyncActionData::SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionData)
+}
+SyncActionData::SyncActionData(const SyncActionData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){}
+    , decltype(_impl_.padding_){}
+    , decltype(_impl_.value_){nullptr}
+    , decltype(_impl_.version_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.index_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.index_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_index()) {
+    _this->_impl_.index_.Set(from._internal_index(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.padding_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.padding_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_padding()) {
+    _this->_impl_.padding_.Set(from._internal_padding(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_value()) {
+    _this->_impl_.value_ = new ::proto::SyncActionValue(*from._impl_.value_);
+  }
+  _this->_impl_.version_ = from._impl_.version_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionData)
+}
+
+inline void SyncActionData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){}
+    , decltype(_impl_.padding_){}
+    , decltype(_impl_.value_){nullptr}
+    , decltype(_impl_.version_){0}
+  };
+  _impl_.index_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.index_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.padding_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.padding_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionData::~SyncActionData() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.index_.Destroy();
+  _impl_.padding_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.value_;
+}
+
+void SyncActionData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionData::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.index_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.padding_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.value_ != nullptr);
+      _impl_.value_->Clear();
+    }
+  }
+  _impl_.version_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes index = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_index();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes padding = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_padding();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 version = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_version(&has_bits);
+          _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes index = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_index(), target);
+  }
+
+  // optional .proto.SyncActionValue value = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::value(this),
+        _Internal::value(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes padding = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_padding(), target);
+  }
+
+  // optional int32 version = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionData)
+  return target;
+}
+
+size_t SyncActionData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes index = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_index());
+    }
+
+    // optional bytes padding = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_padding());
+    }
+
+    // optional .proto.SyncActionValue value = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.value_);
+    }
+
+    // optional int32 version = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionData::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionData::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionData::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionData*>(&to_msg);
+  auto& from = static_cast<const SyncActionData&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_index(from._internal_index());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_padding(from._internal_padding());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_value()->::proto::SyncActionValue::MergeFrom(
+          from._internal_value());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.version_ = from._impl_.version_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionData::CopyFrom(const SyncActionData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionData::IsInitialized() const {
+  return true;
+}
+
+void SyncActionData::InternalSwap(SyncActionData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.index_, lhs_arena,
+      &other->_impl_.index_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.padding_, lhs_arena,
+      &other->_impl_.padding_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.version_)
+      + sizeof(SyncActionData::_impl_.version_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.value_)>(
+          reinterpret_cast<char*>(&_impl_.value_),
+          reinterpret_cast<char*>(&other->_impl_.value_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionData::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[174]);
+}
+
+// ===================================================================
+
+class SyncActionValue_AgentAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_AgentAction>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_deviceid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_isdeleted(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+SyncActionValue_AgentAction::SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AgentAction)
+}
+SyncActionValue_AgentAction::SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_AgentAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.deviceid_){}
+    , decltype(_impl_.isdeleted_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.deviceid_, &from._impl_.deviceid_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.isdeleted_) -
+    reinterpret_cast<char*>(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AgentAction)
+}
+
+inline void SyncActionValue_AgentAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.deviceid_){0}
+    , decltype(_impl_.isdeleted_){false}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_AgentAction::~SyncActionValue_AgentAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.AgentAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_AgentAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void SyncActionValue_AgentAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_AgentAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AgentAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.deviceid_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.isdeleted_) -
+        reinterpret_cast<char*>(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_AgentAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.AgentAction.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 deviceID = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_deviceid(&has_bits);
+          _impl_.deviceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isDeleted = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_isdeleted(&has_bits);
+          _impl_.isdeleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_AgentAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AgentAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.AgentAction.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional int32 deviceID = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_deviceid(), target);
+  }
+
+  // optional bool isDeleted = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_isdeleted(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.AgentAction)
+  return target;
+}
+
+size_t SyncActionValue_AgentAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AgentAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional int32 deviceID = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_deviceid());
+    }
+
+    // optional bool isDeleted = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AgentAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_AgentAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AgentAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_AgentAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_AgentAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_AgentAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AgentAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.deviceid_ = from._impl_.deviceid_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.isdeleted_ = from._impl_.isdeleted_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_AgentAction::CopyFrom(const SyncActionValue_AgentAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AgentAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_AgentAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_AgentAction::InternalSwap(SyncActionValue_AgentAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.isdeleted_)
+      + sizeof(SyncActionValue_AgentAction::_impl_.isdeleted_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.deviceid_)>(
+          reinterpret_cast<char*>(&_impl_.deviceid_),
+          reinterpret_cast<char*>(&other->_impl_.deviceid_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AgentAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[175]);
+}
+
+// ===================================================================
+
+class SyncActionValue_AndroidUnsupportedActions::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_AndroidUnsupportedActions>()._impl_._has_bits_);
+  static void set_has_allowed(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AndroidUnsupportedActions)
+}
+SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_AndroidUnsupportedActions* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.allowed_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.allowed_ = from._impl_.allowed_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AndroidUnsupportedActions)
+}
+
+inline void SyncActionValue_AndroidUnsupportedActions::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.allowed_){false}
+  };
+}
+
+SyncActionValue_AndroidUnsupportedActions::~SyncActionValue_AndroidUnsupportedActions() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.AndroidUnsupportedActions)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_AndroidUnsupportedActions::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_AndroidUnsupportedActions::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_AndroidUnsupportedActions::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AndroidUnsupportedActions)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.allowed_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_AndroidUnsupportedActions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool allowed = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_allowed(&has_bits);
+          _impl_.allowed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_AndroidUnsupportedActions::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AndroidUnsupportedActions)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool allowed = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_allowed(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.AndroidUnsupportedActions)
+  return target;
+}
+
+size_t SyncActionValue_AndroidUnsupportedActions::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AndroidUnsupportedActions)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool allowed = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AndroidUnsupportedActions::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_AndroidUnsupportedActions::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AndroidUnsupportedActions::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_AndroidUnsupportedActions::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_AndroidUnsupportedActions*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_AndroidUnsupportedActions&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AndroidUnsupportedActions)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_allowed()) {
+    _this->_internal_set_allowed(from._internal_allowed());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_AndroidUnsupportedActions::CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AndroidUnsupportedActions)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_AndroidUnsupportedActions::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_AndroidUnsupportedActions::InternalSwap(SyncActionValue_AndroidUnsupportedActions* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.allowed_, other->_impl_.allowed_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AndroidUnsupportedActions::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[176]);
+}
+
+// ===================================================================
+
+class SyncActionValue_ArchiveChatAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_ArchiveChatAction>()._impl_._has_bits_);
+  static void set_has_archived(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ArchiveChatAction* msg);
+  static void set_has_messagerange(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SyncActionValue_SyncActionMessageRange&
+SyncActionValue_ArchiveChatAction::_Internal::messagerange(const SyncActionValue_ArchiveChatAction* msg) {
+  return *msg->_impl_.messagerange_;
+}
+SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ArchiveChatAction)
+}
+SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_ArchiveChatAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+    , decltype(_impl_.archived_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_messagerange()) {
+    _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_);
+  }
+  _this->_impl_.archived_ = from._impl_.archived_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ArchiveChatAction)
+}
+
+inline void SyncActionValue_ArchiveChatAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+    , decltype(_impl_.archived_){false}
+  };
+}
+
+SyncActionValue_ArchiveChatAction::~SyncActionValue_ArchiveChatAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.ArchiveChatAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_ArchiveChatAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.messagerange_;
+}
+
+void SyncActionValue_ArchiveChatAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_ArchiveChatAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ArchiveChatAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.messagerange_ != nullptr);
+    _impl_.messagerange_->Clear();
+  }
+  _impl_.archived_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_ArchiveChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool archived = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_archived(&has_bits);
+          _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_ArchiveChatAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ArchiveChatAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool archived = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_archived(), target);
+  }
+
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::messagerange(this),
+        _Internal::messagerange(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.ArchiveChatAction)
+  return target;
+}
+
+size_t SyncActionValue_ArchiveChatAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ArchiveChatAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.messagerange_);
+    }
+
+    // optional bool archived = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ArchiveChatAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_ArchiveChatAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ArchiveChatAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_ArchiveChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_ArchiveChatAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_ArchiveChatAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ArchiveChatAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom(
+          from._internal_messagerange());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.archived_ = from._impl_.archived_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_ArchiveChatAction::CopyFrom(const SyncActionValue_ArchiveChatAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ArchiveChatAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_ArchiveChatAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_ArchiveChatAction::InternalSwap(SyncActionValue_ArchiveChatAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.archived_)
+      + sizeof(SyncActionValue_ArchiveChatAction::_impl_.archived_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.messagerange_)>(
+          reinterpret_cast<char*>(&_impl_.messagerange_),
+          reinterpret_cast<char*>(&other->_impl_.messagerange_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ArchiveChatAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[177]);
+}
+
+// ===================================================================
+
+class SyncActionValue_ClearChatAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_ClearChatAction>()._impl_._has_bits_);
+  static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ClearChatAction* msg);
+  static void set_has_messagerange(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SyncActionValue_SyncActionMessageRange&
+SyncActionValue_ClearChatAction::_Internal::messagerange(const SyncActionValue_ClearChatAction* msg) {
+  return *msg->_impl_.messagerange_;
+}
+SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ClearChatAction)
+}
+SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_ClearChatAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_messagerange()) {
+    _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ClearChatAction)
+}
+
+inline void SyncActionValue_ClearChatAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+  };
+}
+
+SyncActionValue_ClearChatAction::~SyncActionValue_ClearChatAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.ClearChatAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_ClearChatAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.messagerange_;
+}
+
+void SyncActionValue_ClearChatAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_ClearChatAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ClearChatAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.messagerange_ != nullptr);
+    _impl_.messagerange_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_ClearChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_ClearChatAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ClearChatAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::messagerange(this),
+        _Internal::messagerange(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.ClearChatAction)
+  return target;
+}
+
+size_t SyncActionValue_ClearChatAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ClearChatAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.messagerange_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ClearChatAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_ClearChatAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ClearChatAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_ClearChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_ClearChatAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_ClearChatAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ClearChatAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_messagerange()) {
+    _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom(
+        from._internal_messagerange());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_ClearChatAction::CopyFrom(const SyncActionValue_ClearChatAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ClearChatAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_ClearChatAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_ClearChatAction::InternalSwap(SyncActionValue_ClearChatAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.messagerange_, other->_impl_.messagerange_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ClearChatAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[178]);
+}
+
+// ===================================================================
+
+class SyncActionValue_ContactAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_ContactAction>()._impl_._has_bits_);
+  static void set_has_fullname(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_firstname(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+SyncActionValue_ContactAction::SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ContactAction)
+}
+SyncActionValue_ContactAction::SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_ContactAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.fullname_){}
+    , decltype(_impl_.firstname_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.fullname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fullname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fullname()) {
+    _this->_impl_.fullname_.Set(from._internal_fullname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.firstname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_firstname()) {
+    _this->_impl_.firstname_.Set(from._internal_firstname(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ContactAction)
+}
+
+inline void SyncActionValue_ContactAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.fullname_){}
+    , decltype(_impl_.firstname_){}
+  };
+  _impl_.fullname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fullname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.firstname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.firstname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_ContactAction::~SyncActionValue_ContactAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.ContactAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_ContactAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.fullname_.Destroy();
+  _impl_.firstname_.Destroy();
+}
+
+void SyncActionValue_ContactAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_ContactAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ContactAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.fullname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.firstname_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_ContactAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string fullName = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_fullname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.fullName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string firstName = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_firstname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.firstName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_ContactAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ContactAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string fullName = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_fullname().data(), static_cast<int>(this->_internal_fullname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.ContactAction.fullName");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_fullname(), target);
+  }
+
+  // optional string firstName = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_firstname().data(), static_cast<int>(this->_internal_firstname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.ContactAction.firstName");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_firstname(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.ContactAction)
+  return target;
+}
+
+size_t SyncActionValue_ContactAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ContactAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string fullName = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_fullname());
+    }
+
+    // optional string firstName = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_firstname());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ContactAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_ContactAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ContactAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_ContactAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_ContactAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_ContactAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ContactAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_fullname(from._internal_fullname());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_firstname(from._internal_firstname());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_ContactAction::CopyFrom(const SyncActionValue_ContactAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ContactAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_ContactAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_ContactAction::InternalSwap(SyncActionValue_ContactAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fullname_, lhs_arena,
+      &other->_impl_.fullname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.firstname_, lhs_arena,
+      &other->_impl_.firstname_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ContactAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[179]);
+}
+
+// ===================================================================
+
+class SyncActionValue_DeleteChatAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_DeleteChatAction>()._impl_._has_bits_);
+  static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_DeleteChatAction* msg);
+  static void set_has_messagerange(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SyncActionValue_SyncActionMessageRange&
+SyncActionValue_DeleteChatAction::_Internal::messagerange(const SyncActionValue_DeleteChatAction* msg) {
+  return *msg->_impl_.messagerange_;
+}
+SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteChatAction)
+}
+SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_DeleteChatAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_messagerange()) {
+    _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteChatAction)
+}
+
+inline void SyncActionValue_DeleteChatAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+  };
+}
+
+SyncActionValue_DeleteChatAction::~SyncActionValue_DeleteChatAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteChatAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_DeleteChatAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.messagerange_;
+}
+
+void SyncActionValue_DeleteChatAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_DeleteChatAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteChatAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.messagerange_ != nullptr);
+    _impl_.messagerange_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_DeleteChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_DeleteChatAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteChatAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::messagerange(this),
+        _Internal::messagerange(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.DeleteChatAction)
+  return target;
+}
+
+size_t SyncActionValue_DeleteChatAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteChatAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.messagerange_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteChatAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_DeleteChatAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteChatAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_DeleteChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_DeleteChatAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_DeleteChatAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteChatAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_messagerange()) {
+    _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom(
+        from._internal_messagerange());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_DeleteChatAction::CopyFrom(const SyncActionValue_DeleteChatAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteChatAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_DeleteChatAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_DeleteChatAction::InternalSwap(SyncActionValue_DeleteChatAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.messagerange_, other->_impl_.messagerange_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteChatAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[180]);
+}
+
+// ===================================================================
+
+class SyncActionValue_DeleteMessageForMeAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_DeleteMessageForMeAction>()._impl_._has_bits_);
+  static void set_has_deletemedia(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_messagetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteMessageForMeAction)
+}
+SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_DeleteMessageForMeAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagetimestamp_){}
+    , decltype(_impl_.deletemedia_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deletemedia_) -
+    reinterpret_cast<char*>(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteMessageForMeAction)
+}
+
+inline void SyncActionValue_DeleteMessageForMeAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagetimestamp_){int64_t{0}}
+    , decltype(_impl_.deletemedia_){false}
+  };
+}
+
+SyncActionValue_DeleteMessageForMeAction::~SyncActionValue_DeleteMessageForMeAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteMessageForMeAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_DeleteMessageForMeAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_DeleteMessageForMeAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_DeleteMessageForMeAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteMessageForMeAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.messagetimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deletemedia_) -
+        reinterpret_cast<char*>(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_DeleteMessageForMeAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool deleteMedia = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_deletemedia(&has_bits);
+          _impl_.deletemedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 messageTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_messagetimestamp(&has_bits);
+          _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_DeleteMessageForMeAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteMessageForMeAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool deleteMedia = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_deletemedia(), target);
+  }
+
+  // optional int64 messageTimestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_messagetimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.DeleteMessageForMeAction)
+  return target;
+}
+
+size_t SyncActionValue_DeleteMessageForMeAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteMessageForMeAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional int64 messageTimestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_messagetimestamp());
+    }
+
+    // optional bool deleteMedia = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteMessageForMeAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_DeleteMessageForMeAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteMessageForMeAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_DeleteMessageForMeAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_DeleteMessageForMeAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_DeleteMessageForMeAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteMessageForMeAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.deletemedia_ = from._impl_.deletemedia_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_DeleteMessageForMeAction::CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteMessageForMeAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_DeleteMessageForMeAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_DeleteMessageForMeAction::InternalSwap(SyncActionValue_DeleteMessageForMeAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_)
+      + sizeof(SyncActionValue_DeleteMessageForMeAction::_impl_.deletemedia_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.messagetimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.messagetimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteMessageForMeAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[181]);
+}
+
+// ===================================================================
+
+class SyncActionValue_KeyExpiration::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_KeyExpiration>()._impl_._has_bits_);
+  static void set_has_expiredkeyepoch(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.KeyExpiration)
+}
+SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_KeyExpiration* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expiredkeyepoch_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.expiredkeyepoch_ = from._impl_.expiredkeyepoch_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.KeyExpiration)
+}
+
+inline void SyncActionValue_KeyExpiration::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expiredkeyepoch_){0}
+  };
+}
+
+SyncActionValue_KeyExpiration::~SyncActionValue_KeyExpiration() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.KeyExpiration)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_KeyExpiration::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_KeyExpiration::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_KeyExpiration::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.KeyExpiration)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.expiredkeyepoch_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_KeyExpiration::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 expiredKeyEpoch = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_expiredkeyepoch(&has_bits);
+          _impl_.expiredkeyepoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_KeyExpiration::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.KeyExpiration)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 expiredKeyEpoch = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_expiredkeyepoch(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.KeyExpiration)
+  return target;
+}
+
+size_t SyncActionValue_KeyExpiration::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.KeyExpiration)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional int32 expiredKeyEpoch = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_expiredkeyepoch());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_KeyExpiration::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_KeyExpiration::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_KeyExpiration::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_KeyExpiration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_KeyExpiration*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_KeyExpiration&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.KeyExpiration)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_expiredkeyepoch()) {
+    _this->_internal_set_expiredkeyepoch(from._internal_expiredkeyepoch());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_KeyExpiration::CopyFrom(const SyncActionValue_KeyExpiration& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.KeyExpiration)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_KeyExpiration::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_KeyExpiration::InternalSwap(SyncActionValue_KeyExpiration* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.expiredkeyepoch_, other->_impl_.expiredkeyepoch_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_KeyExpiration::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[182]);
+}
+
+// ===================================================================
+
+class SyncActionValue_LabelAssociationAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_LabelAssociationAction>()._impl_._has_bits_);
+  static void set_has_labeled(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelAssociationAction)
+}
+SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_LabelAssociationAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.labeled_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.labeled_ = from._impl_.labeled_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelAssociationAction)
+}
+
+inline void SyncActionValue_LabelAssociationAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.labeled_){false}
+  };
+}
+
+SyncActionValue_LabelAssociationAction::~SyncActionValue_LabelAssociationAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelAssociationAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_LabelAssociationAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_LabelAssociationAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_LabelAssociationAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelAssociationAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.labeled_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_LabelAssociationAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool labeled = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_labeled(&has_bits);
+          _impl_.labeled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_LabelAssociationAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelAssociationAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool labeled = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_labeled(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.LabelAssociationAction)
+  return target;
+}
+
+size_t SyncActionValue_LabelAssociationAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelAssociationAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool labeled = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelAssociationAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_LabelAssociationAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelAssociationAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_LabelAssociationAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_LabelAssociationAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_LabelAssociationAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelAssociationAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_labeled()) {
+    _this->_internal_set_labeled(from._internal_labeled());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_LabelAssociationAction::CopyFrom(const SyncActionValue_LabelAssociationAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelAssociationAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_LabelAssociationAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_LabelAssociationAction::InternalSwap(SyncActionValue_LabelAssociationAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.labeled_, other->_impl_.labeled_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelAssociationAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[183]);
+}
+
+// ===================================================================
+
+class SyncActionValue_LabelEditAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_LabelEditAction>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_color(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_predefinedid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_deleted(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelEditAction)
+}
+SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_LabelEditAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.color_){}
+    , decltype(_impl_.predefinedid_){}
+    , decltype(_impl_.deleted_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.color_, &from._impl_.color_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deleted_) -
+    reinterpret_cast<char*>(&_impl_.color_)) + sizeof(_impl_.deleted_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelEditAction)
+}
+
+inline void SyncActionValue_LabelEditAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.color_){0}
+    , decltype(_impl_.predefinedid_){0}
+    , decltype(_impl_.deleted_){false}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_LabelEditAction::~SyncActionValue_LabelEditAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelEditAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_LabelEditAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void SyncActionValue_LabelEditAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_LabelEditAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelEditAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000000eu) {
+    ::memset(&_impl_.color_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deleted_) -
+        reinterpret_cast<char*>(&_impl_.color_)) + sizeof(_impl_.deleted_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_LabelEditAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LabelEditAction.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 color = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_color(&has_bits);
+          _impl_.color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 predefinedId = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_predefinedid(&has_bits);
+          _impl_.predefinedid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool deleted = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_deleted(&has_bits);
+          _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_LabelEditAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelEditAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.LabelEditAction.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional int32 color = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_color(), target);
+  }
+
+  // optional int32 predefinedId = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_predefinedid(), target);
+  }
+
+  // optional bool deleted = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_deleted(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.LabelEditAction)
+  return target;
+}
+
+size_t SyncActionValue_LabelEditAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelEditAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional int32 color = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_color());
+    }
+
+    // optional int32 predefinedId = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_predefinedid());
+    }
+
+    // optional bool deleted = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelEditAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_LabelEditAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelEditAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_LabelEditAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_LabelEditAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_LabelEditAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelEditAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.color_ = from._impl_.color_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.predefinedid_ = from._impl_.predefinedid_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.deleted_ = from._impl_.deleted_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_LabelEditAction::CopyFrom(const SyncActionValue_LabelEditAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelEditAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_LabelEditAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_LabelEditAction::InternalSwap(SyncActionValue_LabelEditAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.deleted_)
+      + sizeof(SyncActionValue_LabelEditAction::_impl_.deleted_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.color_)>(
+          reinterpret_cast<char*>(&_impl_.color_),
+          reinterpret_cast<char*>(&other->_impl_.color_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelEditAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[184]);
+}
+
+// ===================================================================
+
+class SyncActionValue_LocaleSetting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_LocaleSetting>()._impl_._has_bits_);
+  static void set_has_locale(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LocaleSetting)
+}
+SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_LocaleSetting* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.locale_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.locale_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_locale()) {
+    _this->_impl_.locale_.Set(from._internal_locale(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LocaleSetting)
+}
+
+inline void SyncActionValue_LocaleSetting::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.locale_){}
+  };
+  _impl_.locale_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_LocaleSetting::~SyncActionValue_LocaleSetting() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.LocaleSetting)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_LocaleSetting::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.locale_.Destroy();
+}
+
+void SyncActionValue_LocaleSetting::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_LocaleSetting::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LocaleSetting)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.locale_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_LocaleSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string locale = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_locale();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LocaleSetting.locale");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_LocaleSetting::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LocaleSetting)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string locale = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_locale().data(), static_cast<int>(this->_internal_locale().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.LocaleSetting.locale");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_locale(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.LocaleSetting)
+  return target;
+}
+
+size_t SyncActionValue_LocaleSetting::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LocaleSetting)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string locale = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_locale());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LocaleSetting::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_LocaleSetting::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LocaleSetting::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_LocaleSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_LocaleSetting*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_LocaleSetting&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LocaleSetting)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_locale()) {
+    _this->_internal_set_locale(from._internal_locale());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_LocaleSetting::CopyFrom(const SyncActionValue_LocaleSetting& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LocaleSetting)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_LocaleSetting::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_LocaleSetting::InternalSwap(SyncActionValue_LocaleSetting* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.locale_, lhs_arena,
+      &other->_impl_.locale_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LocaleSetting::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[185]);
+}
+
+// ===================================================================
+
+class SyncActionValue_MarkChatAsReadAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_MarkChatAsReadAction>()._impl_._has_bits_);
+  static void set_has_read(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_MarkChatAsReadAction* msg);
+  static void set_has_messagerange(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SyncActionValue_SyncActionMessageRange&
+SyncActionValue_MarkChatAsReadAction::_Internal::messagerange(const SyncActionValue_MarkChatAsReadAction* msg) {
+  return *msg->_impl_.messagerange_;
+}
+SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MarkChatAsReadAction)
+}
+SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_MarkChatAsReadAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+    , decltype(_impl_.read_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_messagerange()) {
+    _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_);
+  }
+  _this->_impl_.read_ = from._impl_.read_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MarkChatAsReadAction)
+}
+
+inline void SyncActionValue_MarkChatAsReadAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagerange_){nullptr}
+    , decltype(_impl_.read_){false}
+  };
+}
+
+SyncActionValue_MarkChatAsReadAction::~SyncActionValue_MarkChatAsReadAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.MarkChatAsReadAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_MarkChatAsReadAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.messagerange_;
+}
+
+void SyncActionValue_MarkChatAsReadAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_MarkChatAsReadAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MarkChatAsReadAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.messagerange_ != nullptr);
+    _impl_.messagerange_->Clear();
+  }
+  _impl_.read_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_MarkChatAsReadAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool read = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_read(&has_bits);
+          _impl_.read_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_MarkChatAsReadAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MarkChatAsReadAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool read = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_read(), target);
+  }
+
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::messagerange(this),
+        _Internal::messagerange(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.MarkChatAsReadAction)
+  return target;
+}
+
+size_t SyncActionValue_MarkChatAsReadAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MarkChatAsReadAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.messagerange_);
+    }
+
+    // optional bool read = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MarkChatAsReadAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_MarkChatAsReadAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MarkChatAsReadAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_MarkChatAsReadAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_MarkChatAsReadAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_MarkChatAsReadAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MarkChatAsReadAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom(
+          from._internal_messagerange());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.read_ = from._impl_.read_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_MarkChatAsReadAction::CopyFrom(const SyncActionValue_MarkChatAsReadAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MarkChatAsReadAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_MarkChatAsReadAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_MarkChatAsReadAction::InternalSwap(SyncActionValue_MarkChatAsReadAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.read_)
+      + sizeof(SyncActionValue_MarkChatAsReadAction::_impl_.read_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_)>(
+          reinterpret_cast<char*>(&_impl_.messagerange_),
+          reinterpret_cast<char*>(&other->_impl_.messagerange_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MarkChatAsReadAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[186]);
+}
+
+// ===================================================================
+
+class SyncActionValue_MuteAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_MuteAction>()._impl_._has_bits_);
+  static void set_has_muted(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_muteendtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_MuteAction::SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MuteAction)
+}
+SyncActionValue_MuteAction::SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_MuteAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.muteendtimestamp_){}
+    , decltype(_impl_.muted_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.muteendtimestamp_, &from._impl_.muteendtimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.muted_) -
+    reinterpret_cast<char*>(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MuteAction)
+}
+
+inline void SyncActionValue_MuteAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.muteendtimestamp_){int64_t{0}}
+    , decltype(_impl_.muted_){false}
+  };
+}
+
+SyncActionValue_MuteAction::~SyncActionValue_MuteAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.MuteAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_MuteAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_MuteAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_MuteAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MuteAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.muteendtimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.muted_) -
+        reinterpret_cast<char*>(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_MuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool muted = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_muted(&has_bits);
+          _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 muteEndTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_muteendtimestamp(&has_bits);
+          _impl_.muteendtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_MuteAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MuteAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool muted = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target);
+  }
+
+  // optional int64 muteEndTimestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_muteendtimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.MuteAction)
+  return target;
+}
+
+size_t SyncActionValue_MuteAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MuteAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional int64 muteEndTimestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_muteendtimestamp());
+    }
+
+    // optional bool muted = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MuteAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_MuteAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MuteAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_MuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_MuteAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_MuteAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MuteAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.muteendtimestamp_ = from._impl_.muteendtimestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.muted_ = from._impl_.muted_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_MuteAction::CopyFrom(const SyncActionValue_MuteAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MuteAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_MuteAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_MuteAction::InternalSwap(SyncActionValue_MuteAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muted_)
+      + sizeof(SyncActionValue_MuteAction::_impl_.muted_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muteendtimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.muteendtimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.muteendtimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MuteAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[187]);
+}
+
+// ===================================================================
+
+class SyncActionValue_NuxAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_NuxAction>()._impl_._has_bits_);
+  static void set_has_acknowledged(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_NuxAction::SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.NuxAction)
+}
+SyncActionValue_NuxAction::SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_NuxAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.acknowledged_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.acknowledged_ = from._impl_.acknowledged_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.NuxAction)
+}
+
+inline void SyncActionValue_NuxAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.acknowledged_){false}
+  };
+}
+
+SyncActionValue_NuxAction::~SyncActionValue_NuxAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.NuxAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_NuxAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_NuxAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_NuxAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.NuxAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.acknowledged_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_NuxAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool acknowledged = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_acknowledged(&has_bits);
+          _impl_.acknowledged_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_NuxAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.NuxAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool acknowledged = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_acknowledged(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.NuxAction)
+  return target;
+}
+
+size_t SyncActionValue_NuxAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.NuxAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool acknowledged = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_NuxAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_NuxAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_NuxAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_NuxAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_NuxAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_NuxAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.NuxAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_acknowledged()) {
+    _this->_internal_set_acknowledged(from._internal_acknowledged());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_NuxAction::CopyFrom(const SyncActionValue_NuxAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.NuxAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_NuxAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_NuxAction::InternalSwap(SyncActionValue_NuxAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.acknowledged_, other->_impl_.acknowledged_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_NuxAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[188]);
+}
+
+// ===================================================================
+
+class SyncActionValue_PinAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_PinAction>()._impl_._has_bits_);
+  static void set_has_pinned(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_PinAction::SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PinAction)
+}
+SyncActionValue_PinAction::SyncActionValue_PinAction(const SyncActionValue_PinAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_PinAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pinned_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.pinned_ = from._impl_.pinned_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PinAction)
+}
+
+inline void SyncActionValue_PinAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pinned_){false}
+  };
+}
+
+SyncActionValue_PinAction::~SyncActionValue_PinAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.PinAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_PinAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_PinAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_PinAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PinAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.pinned_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_PinAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool pinned = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_pinned(&has_bits);
+          _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_PinAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PinAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool pinned = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pinned(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.PinAction)
+  return target;
+}
+
+size_t SyncActionValue_PinAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PinAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool pinned = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PinAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_PinAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PinAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_PinAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_PinAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_PinAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PinAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_pinned()) {
+    _this->_internal_set_pinned(from._internal_pinned());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_PinAction::CopyFrom(const SyncActionValue_PinAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PinAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_PinAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_PinAction::InternalSwap(SyncActionValue_PinAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.pinned_, other->_impl_.pinned_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PinAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[189]);
+}
+
+// ===================================================================
+
+class SyncActionValue_PrimaryFeature::_Internal {
+ public:
+};
+
+SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryFeature)
+}
+SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_PrimaryFeature* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.flags_){from._impl_.flags_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryFeature)
+}
+
+inline void SyncActionValue_PrimaryFeature::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.flags_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+SyncActionValue_PrimaryFeature::~SyncActionValue_PrimaryFeature() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryFeature)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_PrimaryFeature::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.flags_.~RepeatedPtrField();
+}
+
+void SyncActionValue_PrimaryFeature::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_PrimaryFeature::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryFeature)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.flags_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_PrimaryFeature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string flags = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_flags();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryFeature.flags");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_PrimaryFeature::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryFeature)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string flags = 1;
+  for (int i = 0, n = this->_internal_flags_size(); i < n; i++) {
+    const auto& s = this->_internal_flags(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.PrimaryFeature.flags");
+    target = stream->WriteString(1, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.PrimaryFeature)
+  return target;
+}
+
+size_t SyncActionValue_PrimaryFeature::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryFeature)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string flags = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.flags_.size());
+  for (int i = 0, n = _impl_.flags_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.flags_.Get(i));
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryFeature::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_PrimaryFeature::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryFeature::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_PrimaryFeature::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_PrimaryFeature*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_PrimaryFeature&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryFeature)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.flags_.MergeFrom(from._impl_.flags_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_PrimaryFeature::CopyFrom(const SyncActionValue_PrimaryFeature& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryFeature)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_PrimaryFeature::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_PrimaryFeature::InternalSwap(SyncActionValue_PrimaryFeature* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.flags_.InternalSwap(&other->_impl_.flags_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryFeature::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[190]);
+}
+
+// ===================================================================
+
+class SyncActionValue_PrimaryVersionAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_PrimaryVersionAction>()._impl_._has_bits_);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryVersionAction)
+}
+SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_PrimaryVersionAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.version_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryVersionAction)
+}
+
+inline void SyncActionValue_PrimaryVersionAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.version_){}
+  };
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_PrimaryVersionAction::~SyncActionValue_PrimaryVersionAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryVersionAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_PrimaryVersionAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.version_.Destroy();
+}
+
+void SyncActionValue_PrimaryVersionAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_PrimaryVersionAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryVersionAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.version_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_PrimaryVersionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryVersionAction.version");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_PrimaryVersionAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryVersionAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string version = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.PrimaryVersionAction.version");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.PrimaryVersionAction)
+  return target;
+}
+
+size_t SyncActionValue_PrimaryVersionAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryVersionAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string version = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_version());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryVersionAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_PrimaryVersionAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryVersionAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_PrimaryVersionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_PrimaryVersionAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_PrimaryVersionAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryVersionAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_version()) {
+    _this->_internal_set_version(from._internal_version());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_PrimaryVersionAction::CopyFrom(const SyncActionValue_PrimaryVersionAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryVersionAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_PrimaryVersionAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_PrimaryVersionAction::InternalSwap(SyncActionValue_PrimaryVersionAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryVersionAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[191]);
+}
+
+// ===================================================================
+
+class SyncActionValue_PushNameSetting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_PushNameSetting>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PushNameSetting)
+}
+SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_PushNameSetting* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PushNameSetting)
+}
+
+inline void SyncActionValue_PushNameSetting::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_PushNameSetting::~SyncActionValue_PushNameSetting() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.PushNameSetting)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_PushNameSetting::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void SyncActionValue_PushNameSetting::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_PushNameSetting::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PushNameSetting)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_PushNameSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PushNameSetting.name");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_PushNameSetting::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PushNameSetting)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.PushNameSetting.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.PushNameSetting)
+  return target;
+}
+
+size_t SyncActionValue_PushNameSetting::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PushNameSetting)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string name = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PushNameSetting::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_PushNameSetting::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PushNameSetting::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_PushNameSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_PushNameSetting*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_PushNameSetting&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PushNameSetting)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_name()) {
+    _this->_internal_set_name(from._internal_name());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_PushNameSetting::CopyFrom(const SyncActionValue_PushNameSetting& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PushNameSetting)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_PushNameSetting::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_PushNameSetting::InternalSwap(SyncActionValue_PushNameSetting* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PushNameSetting::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[192]);
+}
+
+// ===================================================================
+
+class SyncActionValue_QuickReplyAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_QuickReplyAction>()._impl_._has_bits_);
+  static void set_has_shortcut(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_count(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_deleted(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.QuickReplyAction)
+}
+SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_QuickReplyAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keywords_){from._impl_.keywords_}
+    , decltype(_impl_.shortcut_){}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.count_){}
+    , decltype(_impl_.deleted_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.shortcut_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.shortcut_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_shortcut()) {
+    _this->_impl_.shortcut_.Set(from._internal_shortcut(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_message()) {
+    _this->_impl_.message_.Set(from._internal_message(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.count_, &from._impl_.count_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deleted_) -
+    reinterpret_cast<char*>(&_impl_.count_)) + sizeof(_impl_.deleted_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.QuickReplyAction)
+}
+
+inline void SyncActionValue_QuickReplyAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.keywords_){arena}
+    , decltype(_impl_.shortcut_){}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.count_){0}
+    , decltype(_impl_.deleted_){false}
+  };
+  _impl_.shortcut_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.shortcut_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_QuickReplyAction::~SyncActionValue_QuickReplyAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.QuickReplyAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_QuickReplyAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.keywords_.~RepeatedPtrField();
+  _impl_.shortcut_.Destroy();
+  _impl_.message_.Destroy();
+}
+
+void SyncActionValue_QuickReplyAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_QuickReplyAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.QuickReplyAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.keywords_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.shortcut_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.message_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.count_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deleted_) -
+        reinterpret_cast<char*>(&_impl_.count_)) + sizeof(_impl_.deleted_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_QuickReplyAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string shortcut = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_shortcut();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.shortcut");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_message();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.message");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string keywords = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_keywords();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.keywords");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 count = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_count(&has_bits);
+          _impl_.count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool deleted = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_deleted(&has_bits);
+          _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_QuickReplyAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.QuickReplyAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string shortcut = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_shortcut().data(), static_cast<int>(this->_internal_shortcut().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.QuickReplyAction.shortcut");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_shortcut(), target);
+  }
+
+  // optional string message = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.QuickReplyAction.message");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_message(), target);
+  }
+
+  // repeated string keywords = 3;
+  for (int i = 0, n = this->_internal_keywords_size(); i < n; i++) {
+    const auto& s = this->_internal_keywords(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.QuickReplyAction.keywords");
+    target = stream->WriteString(3, s, target);
+  }
+
+  // optional int32 count = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_count(), target);
+  }
+
+  // optional bool deleted = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_deleted(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.QuickReplyAction)
+  return target;
+}
+
+size_t SyncActionValue_QuickReplyAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.QuickReplyAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string keywords = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.keywords_.size());
+  for (int i = 0, n = _impl_.keywords_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.keywords_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string shortcut = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_shortcut());
+    }
+
+    // optional string message = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_message());
+    }
+
+    // optional int32 count = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_count());
+    }
+
+    // optional bool deleted = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_QuickReplyAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_QuickReplyAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_QuickReplyAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_QuickReplyAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_QuickReplyAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_QuickReplyAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.QuickReplyAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.keywords_.MergeFrom(from._impl_.keywords_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_shortcut(from._internal_shortcut());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_message(from._internal_message());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.count_ = from._impl_.count_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.deleted_ = from._impl_.deleted_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_QuickReplyAction::CopyFrom(const SyncActionValue_QuickReplyAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.QuickReplyAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_QuickReplyAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_QuickReplyAction::InternalSwap(SyncActionValue_QuickReplyAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.keywords_.InternalSwap(&other->_impl_.keywords_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.shortcut_, lhs_arena,
+      &other->_impl_.shortcut_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.message_, lhs_arena,
+      &other->_impl_.message_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.deleted_)
+      + sizeof(SyncActionValue_QuickReplyAction::_impl_.deleted_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.count_)>(
+          reinterpret_cast<char*>(&_impl_.count_),
+          reinterpret_cast<char*>(&other->_impl_.count_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_QuickReplyAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[193]);
+}
+
+// ===================================================================
+
+class SyncActionValue_RecentEmojiWeightsAction::_Internal {
+ public:
+};
+
+SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.RecentEmojiWeightsAction)
+}
+SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_RecentEmojiWeightsAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.weights_){from._impl_.weights_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.RecentEmojiWeightsAction)
+}
+
+inline void SyncActionValue_RecentEmojiWeightsAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.weights_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+SyncActionValue_RecentEmojiWeightsAction::~SyncActionValue_RecentEmojiWeightsAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.RecentEmojiWeightsAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_RecentEmojiWeightsAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.weights_.~RepeatedPtrField();
+}
+
+void SyncActionValue_RecentEmojiWeightsAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_RecentEmojiWeightsAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.RecentEmojiWeightsAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.weights_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_RecentEmojiWeightsAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.RecentEmojiWeight weights = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_weights(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_RecentEmojiWeightsAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.RecentEmojiWeightsAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.RecentEmojiWeight weights = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_weights_size()); i < n; i++) {
+    const auto& repfield = this->_internal_weights(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.RecentEmojiWeightsAction)
+  return target;
+}
+
+size_t SyncActionValue_RecentEmojiWeightsAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.RecentEmojiWeightsAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.RecentEmojiWeight weights = 1;
+  total_size += 1UL * this->_internal_weights_size();
+  for (const auto& msg : this->_impl_.weights_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_RecentEmojiWeightsAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_RecentEmojiWeightsAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_RecentEmojiWeightsAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_RecentEmojiWeightsAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_RecentEmojiWeightsAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_RecentEmojiWeightsAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.RecentEmojiWeightsAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.weights_.MergeFrom(from._impl_.weights_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_RecentEmojiWeightsAction::CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.RecentEmojiWeightsAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_RecentEmojiWeightsAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_RecentEmojiWeightsAction::InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.weights_.InternalSwap(&other->_impl_.weights_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_RecentEmojiWeightsAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[194]);
+}
+
+// ===================================================================
+
+class SyncActionValue_SecurityNotificationSetting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_SecurityNotificationSetting>()._impl_._has_bits_);
+  static void set_has_shownotification(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SecurityNotificationSetting)
+}
+SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_SecurityNotificationSetting* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.shownotification_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.shownotification_ = from._impl_.shownotification_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SecurityNotificationSetting)
+}
+
+inline void SyncActionValue_SecurityNotificationSetting::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.shownotification_){false}
+  };
+}
+
+SyncActionValue_SecurityNotificationSetting::~SyncActionValue_SecurityNotificationSetting() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.SecurityNotificationSetting)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_SecurityNotificationSetting::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_SecurityNotificationSetting::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_SecurityNotificationSetting::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SecurityNotificationSetting)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.shownotification_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_SecurityNotificationSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool showNotification = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_shownotification(&has_bits);
+          _impl_.shownotification_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_SecurityNotificationSetting::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SecurityNotificationSetting)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool showNotification = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_shownotification(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.SecurityNotificationSetting)
+  return target;
+}
+
+size_t SyncActionValue_SecurityNotificationSetting::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SecurityNotificationSetting)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool showNotification = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SecurityNotificationSetting::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_SecurityNotificationSetting::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SecurityNotificationSetting::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_SecurityNotificationSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_SecurityNotificationSetting*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_SecurityNotificationSetting&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SecurityNotificationSetting)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_shownotification()) {
+    _this->_internal_set_shownotification(from._internal_shownotification());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_SecurityNotificationSetting::CopyFrom(const SyncActionValue_SecurityNotificationSetting& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SecurityNotificationSetting)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_SecurityNotificationSetting::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_SecurityNotificationSetting::InternalSwap(SyncActionValue_SecurityNotificationSetting* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.shownotification_, other->_impl_.shownotification_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SecurityNotificationSetting::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[195]);
+}
+
+// ===================================================================
+
+class SyncActionValue_StarAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_StarAction>()._impl_._has_bits_);
+  static void set_has_starred(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_StarAction::SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StarAction)
+}
+SyncActionValue_StarAction::SyncActionValue_StarAction(const SyncActionValue_StarAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_StarAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.starred_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.starred_ = from._impl_.starred_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StarAction)
+}
+
+inline void SyncActionValue_StarAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.starred_){false}
+  };
+}
+
+SyncActionValue_StarAction::~SyncActionValue_StarAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.StarAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_StarAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_StarAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_StarAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StarAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.starred_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_StarAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool starred = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_starred(&has_bits);
+          _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_StarAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StarAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool starred = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_starred(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.StarAction)
+  return target;
+}
+
+size_t SyncActionValue_StarAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StarAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool starred = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StarAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_StarAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StarAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_StarAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_StarAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_StarAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StarAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_starred()) {
+    _this->_internal_set_starred(from._internal_starred());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_StarAction::CopyFrom(const SyncActionValue_StarAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StarAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_StarAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_StarAction::InternalSwap(SyncActionValue_StarAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.starred_, other->_impl_.starred_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StarAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[196]);
+}
+
+// ===================================================================
+
+class SyncActionValue_StickerAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_StickerAction>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_fileencsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_mediakey(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_mimetype(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_directpath(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_filelength(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_isfavorite(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_deviceidhint(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+SyncActionValue_StickerAction::SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StickerAction)
+}
+SyncActionValue_StickerAction::SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_StickerAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.height_){}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.filelength_){}
+    , decltype(_impl_.isfavorite_){}
+    , decltype(_impl_.deviceidhint_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_fileencsha256()) {
+    _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediakey()) {
+    _this->_impl_.mediakey_.Set(from._internal_mediakey(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mimetype()) {
+    _this->_impl_.mimetype_.Set(from._internal_mimetype(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directpath()) {
+    _this->_impl_.directpath_.Set(from._internal_directpath(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.height_, &from._impl_.height_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deviceidhint_) -
+    reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.deviceidhint_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StickerAction)
+}
+
+inline void SyncActionValue_StickerAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.fileencsha256_){}
+    , decltype(_impl_.mediakey_){}
+    , decltype(_impl_.mimetype_){}
+    , decltype(_impl_.directpath_){}
+    , decltype(_impl_.height_){0u}
+    , decltype(_impl_.width_){0u}
+    , decltype(_impl_.filelength_){uint64_t{0u}}
+    , decltype(_impl_.isfavorite_){false}
+    , decltype(_impl_.deviceidhint_){0u}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.fileencsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediakey_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mimetype_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.directpath_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncActionValue_StickerAction::~SyncActionValue_StickerAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.StickerAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_StickerAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.fileencsha256_.Destroy();
+  _impl_.mediakey_.Destroy();
+  _impl_.mimetype_.Destroy();
+  _impl_.directpath_.Destroy();
+}
+
+void SyncActionValue_StickerAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_StickerAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StickerAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.fileencsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.mediakey_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.mimetype_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.directpath_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    ::memset(&_impl_.height_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.filelength_) -
+        reinterpret_cast<char*>(&_impl_.height_)) + sizeof(_impl_.filelength_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.isfavorite_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deviceidhint_) -
+        reinterpret_cast<char*>(&_impl_.isfavorite_)) + sizeof(_impl_.deviceidhint_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_StickerAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.url");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes fileEncSha256 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_fileencsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaKey = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_mediakey();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mimetype = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_mimetype();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.mimetype");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 height = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 width = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string directPath = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_directpath();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.directPath");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 fileLength = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_filelength(&has_bits);
+          _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isFavorite = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_isfavorite(&has_bits);
+          _impl_.isfavorite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 deviceIdHint = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_deviceidhint(&has_bits);
+          _impl_.deviceidhint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_StickerAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StickerAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_url().data(), static_cast<int>(this->_internal_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.StickerAction.url");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional bytes fileEncSha256 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_fileencsha256(), target);
+  }
+
+  // optional bytes mediaKey = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_mediakey(), target);
+  }
+
+  // optional string mimetype = 4;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_mimetype().data(), static_cast<int>(this->_internal_mimetype().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.StickerAction.mimetype");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_mimetype(), target);
+  }
+
+  // optional uint32 height = 5;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_height(), target);
+  }
+
+  // optional uint32 width = 6;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_width(), target);
+  }
+
+  // optional string directPath = 7;
+  if (cached_has_bits & 0x00000010u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_directpath().data(), static_cast<int>(this->_internal_directpath().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.SyncActionValue.StickerAction.directPath");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_directpath(), target);
+  }
+
+  // optional uint64 fileLength = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_filelength(), target);
+  }
+
+  // optional bool isFavorite = 9;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_isfavorite(), target);
+  }
+
+  // optional uint32 deviceIdHint = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_deviceidhint(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.StickerAction)
+  return target;
+}
+
+size_t SyncActionValue_StickerAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StickerAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional bytes fileEncSha256 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fileencsha256());
+    }
+
+    // optional bytes mediaKey = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediakey());
+    }
+
+    // optional string mimetype = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mimetype());
+    }
+
+    // optional string directPath = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_directpath());
+    }
+
+    // optional uint32 height = 5;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height());
+    }
+
+    // optional uint32 width = 6;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width());
+    }
+
+    // optional uint64 fileLength = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength());
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional bool isFavorite = 9;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint32 deviceIdHint = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceidhint());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StickerAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_StickerAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StickerAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_StickerAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_StickerAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_StickerAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StickerAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_fileencsha256(from._internal_fileencsha256());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_mediakey(from._internal_mediakey());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_mimetype(from._internal_mimetype());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_directpath(from._internal_directpath());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.filelength_ = from._impl_.filelength_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.isfavorite_ = from._impl_.isfavorite_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.deviceidhint_ = from._impl_.deviceidhint_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_StickerAction::CopyFrom(const SyncActionValue_StickerAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StickerAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_StickerAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_StickerAction::InternalSwap(SyncActionValue_StickerAction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.fileencsha256_, lhs_arena,
+      &other->_impl_.fileencsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediakey_, lhs_arena,
+      &other->_impl_.mediakey_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mimetype_, lhs_arena,
+      &other->_impl_.mimetype_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directpath_, lhs_arena,
+      &other->_impl_.directpath_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.deviceidhint_)
+      + sizeof(SyncActionValue_StickerAction::_impl_.deviceidhint_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.height_)>(
+          reinterpret_cast<char*>(&_impl_.height_),
+          reinterpret_cast<char*>(&other->_impl_.height_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StickerAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[197]);
+}
+
+// ===================================================================
+
+class SyncActionValue_SubscriptionAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_SubscriptionAction>()._impl_._has_bits_);
+  static void set_has_isdeactivated(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_isautorenewing(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_expirationdate(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SubscriptionAction)
+}
+SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_SubscriptionAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expirationdate_){}
+    , decltype(_impl_.isdeactivated_){}
+    , decltype(_impl_.isautorenewing_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.expirationdate_, &from._impl_.expirationdate_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.isautorenewing_) -
+    reinterpret_cast<char*>(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SubscriptionAction)
+}
+
+inline void SyncActionValue_SubscriptionAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.expirationdate_){int64_t{0}}
+    , decltype(_impl_.isdeactivated_){false}
+    , decltype(_impl_.isautorenewing_){false}
+  };
+}
+
+SyncActionValue_SubscriptionAction::~SyncActionValue_SubscriptionAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.SubscriptionAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_SubscriptionAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_SubscriptionAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_SubscriptionAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SubscriptionAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.expirationdate_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.isautorenewing_) -
+        reinterpret_cast<char*>(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_SubscriptionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool isDeactivated = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_isdeactivated(&has_bits);
+          _impl_.isdeactivated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool isAutoRenewing = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_isautorenewing(&has_bits);
+          _impl_.isautorenewing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 expirationDate = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_expirationdate(&has_bits);
+          _impl_.expirationdate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_SubscriptionAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SubscriptionAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool isDeactivated = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_isdeactivated(), target);
+  }
+
+  // optional bool isAutoRenewing = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_isautorenewing(), target);
+  }
+
+  // optional int64 expirationDate = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_expirationdate(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.SubscriptionAction)
+  return target;
+}
+
+size_t SyncActionValue_SubscriptionAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SubscriptionAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional int64 expirationDate = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirationdate());
+    }
+
+    // optional bool isDeactivated = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool isAutoRenewing = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SubscriptionAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_SubscriptionAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SubscriptionAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_SubscriptionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_SubscriptionAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_SubscriptionAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SubscriptionAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.expirationdate_ = from._impl_.expirationdate_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.isdeactivated_ = from._impl_.isdeactivated_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.isautorenewing_ = from._impl_.isautorenewing_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_SubscriptionAction::CopyFrom(const SyncActionValue_SubscriptionAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SubscriptionAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_SubscriptionAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_SubscriptionAction::InternalSwap(SyncActionValue_SubscriptionAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.isautorenewing_)
+      + sizeof(SyncActionValue_SubscriptionAction::_impl_.isautorenewing_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.expirationdate_)>(
+          reinterpret_cast<char*>(&_impl_.expirationdate_),
+          reinterpret_cast<char*>(&other->_impl_.expirationdate_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SubscriptionAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[198]);
+}
+
+// ===================================================================
+
+class SyncActionValue_SyncActionMessageRange::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_SyncActionMessageRange>()._impl_._has_bits_);
+  static void set_has_lastmessagetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_lastsystemmessagetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessageRange)
+}
+SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_SyncActionMessageRange* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messages_){from._impl_.messages_}
+    , decltype(_impl_.lastmessagetimestamp_){}
+    , decltype(_impl_.lastsystemmessagetimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.lastmessagetimestamp_, &from._impl_.lastmessagetimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.lastsystemmessagetimestamp_) -
+    reinterpret_cast<char*>(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessageRange)
+}
+
+inline void SyncActionValue_SyncActionMessageRange::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messages_){arena}
+    , decltype(_impl_.lastmessagetimestamp_){int64_t{0}}
+    , decltype(_impl_.lastsystemmessagetimestamp_){int64_t{0}}
+  };
+}
+
+SyncActionValue_SyncActionMessageRange::~SyncActionValue_SyncActionMessageRange() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessageRange)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_SyncActionMessageRange::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.messages_.~RepeatedPtrField();
+}
+
+void SyncActionValue_SyncActionMessageRange::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_SyncActionMessageRange::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessageRange)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.messages_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.lastmessagetimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.lastsystemmessagetimestamp_) -
+        reinterpret_cast<char*>(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_SyncActionMessageRange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int64 lastMessageTimestamp = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_lastmessagetimestamp(&has_bits);
+          _impl_.lastmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 lastSystemMessageTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_lastsystemmessagetimestamp(&has_bits);
+          _impl_.lastsystemmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_messages(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_SyncActionMessageRange::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessageRange)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 lastMessageTimestamp = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_lastmessagetimestamp(), target);
+  }
+
+  // optional int64 lastSystemMessageTimestamp = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_lastsystemmessagetimestamp(), target);
+  }
+
+  // repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_messages_size()); i < n; i++) {
+    const auto& repfield = this->_internal_messages(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.SyncActionMessageRange)
+  return target;
+}
+
+size_t SyncActionValue_SyncActionMessageRange::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessageRange)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
+  total_size += 1UL * this->_internal_messages_size();
+  for (const auto& msg : this->_impl_.messages_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional int64 lastMessageTimestamp = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastmessagetimestamp());
+    }
+
+    // optional int64 lastSystemMessageTimestamp = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastsystemmessagetimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessageRange::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_SyncActionMessageRange::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessageRange::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_SyncActionMessageRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_SyncActionMessageRange*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_SyncActionMessageRange&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessageRange)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.messages_.MergeFrom(from._impl_.messages_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.lastmessagetimestamp_ = from._impl_.lastmessagetimestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.lastsystemmessagetimestamp_ = from._impl_.lastsystemmessagetimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_SyncActionMessageRange::CopyFrom(const SyncActionValue_SyncActionMessageRange& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessageRange)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_SyncActionMessageRange::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_SyncActionMessageRange::InternalSwap(SyncActionValue_SyncActionMessageRange* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.messages_.InternalSwap(&other->_impl_.messages_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_)
+      + sizeof(SyncActionValue_SyncActionMessageRange::_impl_.lastsystemmessagetimestamp_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.lastmessagetimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.lastmessagetimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessageRange::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[199]);
+}
+
+// ===================================================================
+
+class SyncActionValue_SyncActionMessage::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_SyncActionMessage>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const SyncActionValue_SyncActionMessage* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::MessageKey&
+SyncActionValue_SyncActionMessage::_Internal::key(const SyncActionValue_SyncActionMessage* msg) {
+  return *msg->_impl_.key_;
+}
+SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessage)
+}
+SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_SyncActionMessage* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.timestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  _this->_impl_.timestamp_ = from._impl_.timestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessage)
+}
+
+inline void SyncActionValue_SyncActionMessage::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+  };
+}
+
+SyncActionValue_SyncActionMessage::~SyncActionValue_SyncActionMessage() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessage)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_SyncActionMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.key_;
+}
+
+void SyncActionValue_SyncActionMessage::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_SyncActionMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessage)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.key_ != nullptr);
+    _impl_.key_->Clear();
+  }
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_SyncActionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_SyncActionMessage::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessage)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 timestamp = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.SyncActionMessage)
+  return target;
+}
+
+size_t SyncActionValue_SyncActionMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessage)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.MessageKey key = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.key_);
+    }
+
+    // optional int64 timestamp = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessage::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_SyncActionMessage::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessage::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_SyncActionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_SyncActionMessage*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_SyncActionMessage&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessage)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_SyncActionMessage::CopyFrom(const SyncActionValue_SyncActionMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_SyncActionMessage::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_SyncActionMessage::InternalSwap(SyncActionValue_SyncActionMessage* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.timestamp_)
+      + sizeof(SyncActionValue_SyncActionMessage::_impl_.timestamp_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessage::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[200]);
+}
+
+// ===================================================================
+
+class SyncActionValue_TimeFormatAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_TimeFormatAction>()._impl_._has_bits_);
+  static void set_has_istwentyfourhourformatenabled(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.TimeFormatAction)
+}
+SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_TimeFormatAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.istwentyfourhourformatenabled_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.istwentyfourhourformatenabled_ = from._impl_.istwentyfourhourformatenabled_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.TimeFormatAction)
+}
+
+inline void SyncActionValue_TimeFormatAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.istwentyfourhourformatenabled_){false}
+  };
+}
+
+SyncActionValue_TimeFormatAction::~SyncActionValue_TimeFormatAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.TimeFormatAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_TimeFormatAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_TimeFormatAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_TimeFormatAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.TimeFormatAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.istwentyfourhourformatenabled_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_TimeFormatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool isTwentyFourHourFormatEnabled = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_istwentyfourhourformatenabled(&has_bits);
+          _impl_.istwentyfourhourformatenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_TimeFormatAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.TimeFormatAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool isTwentyFourHourFormatEnabled = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_istwentyfourhourformatenabled(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.TimeFormatAction)
+  return target;
+}
+
+size_t SyncActionValue_TimeFormatAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.TimeFormatAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool isTwentyFourHourFormatEnabled = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_TimeFormatAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_TimeFormatAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_TimeFormatAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_TimeFormatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_TimeFormatAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_TimeFormatAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.TimeFormatAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_istwentyfourhourformatenabled()) {
+    _this->_internal_set_istwentyfourhourformatenabled(from._internal_istwentyfourhourformatenabled());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_TimeFormatAction::CopyFrom(const SyncActionValue_TimeFormatAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.TimeFormatAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_TimeFormatAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_TimeFormatAction::InternalSwap(SyncActionValue_TimeFormatAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.istwentyfourhourformatenabled_, other->_impl_.istwentyfourhourformatenabled_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_TimeFormatAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[201]);
+}
+
+// ===================================================================
+
+class SyncActionValue_UnarchiveChatsSetting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_UnarchiveChatsSetting>()._impl_._has_bits_);
+  static void set_has_unarchivechats(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UnarchiveChatsSetting)
+}
+SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_UnarchiveChatsSetting* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.unarchivechats_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.unarchivechats_ = from._impl_.unarchivechats_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UnarchiveChatsSetting)
+}
+
+inline void SyncActionValue_UnarchiveChatsSetting::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.unarchivechats_){false}
+  };
+}
+
+SyncActionValue_UnarchiveChatsSetting::~SyncActionValue_UnarchiveChatsSetting() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.UnarchiveChatsSetting)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_UnarchiveChatsSetting::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_UnarchiveChatsSetting::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_UnarchiveChatsSetting::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UnarchiveChatsSetting)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.unarchivechats_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_UnarchiveChatsSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool unarchiveChats = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_unarchivechats(&has_bits);
+          _impl_.unarchivechats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_UnarchiveChatsSetting::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UnarchiveChatsSetting)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool unarchiveChats = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_unarchivechats(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.UnarchiveChatsSetting)
+  return target;
+}
+
+size_t SyncActionValue_UnarchiveChatsSetting::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UnarchiveChatsSetting)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool unarchiveChats = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UnarchiveChatsSetting::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_UnarchiveChatsSetting::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UnarchiveChatsSetting::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_UnarchiveChatsSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_UnarchiveChatsSetting*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_UnarchiveChatsSetting&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UnarchiveChatsSetting)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_unarchivechats()) {
+    _this->_internal_set_unarchivechats(from._internal_unarchivechats());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_UnarchiveChatsSetting::CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UnarchiveChatsSetting)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_UnarchiveChatsSetting::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_UnarchiveChatsSetting::InternalSwap(SyncActionValue_UnarchiveChatsSetting* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.unarchivechats_, other->_impl_.unarchivechats_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UnarchiveChatsSetting::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[202]);
+}
+
+// ===================================================================
+
+class SyncActionValue_UserStatusMuteAction::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue_UserStatusMuteAction>()._impl_._has_bits_);
+  static void set_has_muted(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UserStatusMuteAction)
+}
+SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue_UserStatusMuteAction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.muted_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.muted_ = from._impl_.muted_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UserStatusMuteAction)
+}
+
+inline void SyncActionValue_UserStatusMuteAction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.muted_){false}
+  };
+}
+
+SyncActionValue_UserStatusMuteAction::~SyncActionValue_UserStatusMuteAction() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue.UserStatusMuteAction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue_UserStatusMuteAction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncActionValue_UserStatusMuteAction::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue_UserStatusMuteAction::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UserStatusMuteAction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.muted_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue_UserStatusMuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bool muted = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_muted(&has_bits);
+          _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue_UserStatusMuteAction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UserStatusMuteAction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool muted = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue.UserStatusMuteAction)
+  return target;
+}
+
+size_t SyncActionValue_UserStatusMuteAction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UserStatusMuteAction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bool muted = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UserStatusMuteAction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue_UserStatusMuteAction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UserStatusMuteAction::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue_UserStatusMuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue_UserStatusMuteAction*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue_UserStatusMuteAction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UserStatusMuteAction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_muted()) {
+    _this->_internal_set_muted(from._internal_muted());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue_UserStatusMuteAction::CopyFrom(const SyncActionValue_UserStatusMuteAction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UserStatusMuteAction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue_UserStatusMuteAction::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue_UserStatusMuteAction::InternalSwap(SyncActionValue_UserStatusMuteAction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.muted_, other->_impl_.muted_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UserStatusMuteAction::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[203]);
+}
+
+// ===================================================================
+
+class SyncActionValue::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncActionValue>()._impl_._has_bits_);
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 134217728u;
+  }
+  static const ::proto::SyncActionValue_StarAction& staraction(const SyncActionValue* msg);
+  static void set_has_staraction(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::SyncActionValue_ContactAction& contactaction(const SyncActionValue* msg);
+  static void set_has_contactaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::SyncActionValue_MuteAction& muteaction(const SyncActionValue* msg);
+  static void set_has_muteaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::SyncActionValue_PinAction& pinaction(const SyncActionValue* msg);
+  static void set_has_pinaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting(const SyncActionValue* msg);
+  static void set_has_securitynotificationsetting(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::SyncActionValue_PushNameSetting& pushnamesetting(const SyncActionValue* msg);
+  static void set_has_pushnamesetting(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction(const SyncActionValue* msg);
+  static void set_has_quickreplyaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction(const SyncActionValue* msg);
+  static void set_has_recentemojiweightsaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static const ::proto::SyncActionValue_LabelEditAction& labeleditaction(const SyncActionValue* msg);
+  static void set_has_labeleditaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction(const SyncActionValue* msg);
+  static void set_has_labelassociationaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static const ::proto::SyncActionValue_LocaleSetting& localesetting(const SyncActionValue* msg);
+  static void set_has_localesetting(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static const ::proto::SyncActionValue_ArchiveChatAction& archivechataction(const SyncActionValue* msg);
+  static void set_has_archivechataction(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction(const SyncActionValue* msg);
+  static void set_has_deletemessageformeaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static const ::proto::SyncActionValue_KeyExpiration& keyexpiration(const SyncActionValue* msg);
+  static void set_has_keyexpiration(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction(const SyncActionValue* msg);
+  static void set_has_markchatasreadaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static const ::proto::SyncActionValue_ClearChatAction& clearchataction(const SyncActionValue* msg);
+  static void set_has_clearchataction(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static const ::proto::SyncActionValue_DeleteChatAction& deletechataction(const SyncActionValue* msg);
+  static void set_has_deletechataction(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting(const SyncActionValue* msg);
+  static void set_has_unarchivechatssetting(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static const ::proto::SyncActionValue_PrimaryFeature& primaryfeature(const SyncActionValue* msg);
+  static void set_has_primaryfeature(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions(const SyncActionValue* msg);
+  static void set_has_androidunsupportedactions(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static const ::proto::SyncActionValue_AgentAction& agentaction(const SyncActionValue* msg);
+  static void set_has_agentaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction(const SyncActionValue* msg);
+  static void set_has_subscriptionaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction(const SyncActionValue* msg);
+  static void set_has_userstatusmuteaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static const ::proto::SyncActionValue_TimeFormatAction& timeformataction(const SyncActionValue* msg);
+  static void set_has_timeformataction(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static const ::proto::SyncActionValue_NuxAction& nuxaction(const SyncActionValue* msg);
+  static void set_has_nuxaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 16777216u;
+  }
+  static const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction(const SyncActionValue* msg);
+  static void set_has_primaryversionaction(HasBits* has_bits) {
+    (*has_bits)[0] |= 33554432u;
+  }
+  static const ::proto::SyncActionValue_StickerAction& stickeraction(const SyncActionValue* msg);
+  static void set_has_stickeraction(HasBits* has_bits) {
+    (*has_bits)[0] |= 67108864u;
+  }
+};
+
+const ::proto::SyncActionValue_StarAction&
+SyncActionValue::_Internal::staraction(const SyncActionValue* msg) {
+  return *msg->_impl_.staraction_;
+}
+const ::proto::SyncActionValue_ContactAction&
+SyncActionValue::_Internal::contactaction(const SyncActionValue* msg) {
+  return *msg->_impl_.contactaction_;
+}
+const ::proto::SyncActionValue_MuteAction&
+SyncActionValue::_Internal::muteaction(const SyncActionValue* msg) {
+  return *msg->_impl_.muteaction_;
+}
+const ::proto::SyncActionValue_PinAction&
+SyncActionValue::_Internal::pinaction(const SyncActionValue* msg) {
+  return *msg->_impl_.pinaction_;
+}
+const ::proto::SyncActionValue_SecurityNotificationSetting&
+SyncActionValue::_Internal::securitynotificationsetting(const SyncActionValue* msg) {
+  return *msg->_impl_.securitynotificationsetting_;
+}
+const ::proto::SyncActionValue_PushNameSetting&
+SyncActionValue::_Internal::pushnamesetting(const SyncActionValue* msg) {
+  return *msg->_impl_.pushnamesetting_;
+}
+const ::proto::SyncActionValue_QuickReplyAction&
+SyncActionValue::_Internal::quickreplyaction(const SyncActionValue* msg) {
+  return *msg->_impl_.quickreplyaction_;
+}
+const ::proto::SyncActionValue_RecentEmojiWeightsAction&
+SyncActionValue::_Internal::recentemojiweightsaction(const SyncActionValue* msg) {
+  return *msg->_impl_.recentemojiweightsaction_;
+}
+const ::proto::SyncActionValue_LabelEditAction&
+SyncActionValue::_Internal::labeleditaction(const SyncActionValue* msg) {
+  return *msg->_impl_.labeleditaction_;
+}
+const ::proto::SyncActionValue_LabelAssociationAction&
+SyncActionValue::_Internal::labelassociationaction(const SyncActionValue* msg) {
+  return *msg->_impl_.labelassociationaction_;
+}
+const ::proto::SyncActionValue_LocaleSetting&
+SyncActionValue::_Internal::localesetting(const SyncActionValue* msg) {
+  return *msg->_impl_.localesetting_;
+}
+const ::proto::SyncActionValue_ArchiveChatAction&
+SyncActionValue::_Internal::archivechataction(const SyncActionValue* msg) {
+  return *msg->_impl_.archivechataction_;
+}
+const ::proto::SyncActionValue_DeleteMessageForMeAction&
+SyncActionValue::_Internal::deletemessageformeaction(const SyncActionValue* msg) {
+  return *msg->_impl_.deletemessageformeaction_;
+}
+const ::proto::SyncActionValue_KeyExpiration&
+SyncActionValue::_Internal::keyexpiration(const SyncActionValue* msg) {
+  return *msg->_impl_.keyexpiration_;
+}
+const ::proto::SyncActionValue_MarkChatAsReadAction&
+SyncActionValue::_Internal::markchatasreadaction(const SyncActionValue* msg) {
+  return *msg->_impl_.markchatasreadaction_;
+}
+const ::proto::SyncActionValue_ClearChatAction&
+SyncActionValue::_Internal::clearchataction(const SyncActionValue* msg) {
+  return *msg->_impl_.clearchataction_;
+}
+const ::proto::SyncActionValue_DeleteChatAction&
+SyncActionValue::_Internal::deletechataction(const SyncActionValue* msg) {
+  return *msg->_impl_.deletechataction_;
+}
+const ::proto::SyncActionValue_UnarchiveChatsSetting&
+SyncActionValue::_Internal::unarchivechatssetting(const SyncActionValue* msg) {
+  return *msg->_impl_.unarchivechatssetting_;
+}
+const ::proto::SyncActionValue_PrimaryFeature&
+SyncActionValue::_Internal::primaryfeature(const SyncActionValue* msg) {
+  return *msg->_impl_.primaryfeature_;
+}
+const ::proto::SyncActionValue_AndroidUnsupportedActions&
+SyncActionValue::_Internal::androidunsupportedactions(const SyncActionValue* msg) {
+  return *msg->_impl_.androidunsupportedactions_;
+}
+const ::proto::SyncActionValue_AgentAction&
+SyncActionValue::_Internal::agentaction(const SyncActionValue* msg) {
+  return *msg->_impl_.agentaction_;
+}
+const ::proto::SyncActionValue_SubscriptionAction&
+SyncActionValue::_Internal::subscriptionaction(const SyncActionValue* msg) {
+  return *msg->_impl_.subscriptionaction_;
+}
+const ::proto::SyncActionValue_UserStatusMuteAction&
+SyncActionValue::_Internal::userstatusmuteaction(const SyncActionValue* msg) {
+  return *msg->_impl_.userstatusmuteaction_;
+}
+const ::proto::SyncActionValue_TimeFormatAction&
+SyncActionValue::_Internal::timeformataction(const SyncActionValue* msg) {
+  return *msg->_impl_.timeformataction_;
+}
+const ::proto::SyncActionValue_NuxAction&
+SyncActionValue::_Internal::nuxaction(const SyncActionValue* msg) {
+  return *msg->_impl_.nuxaction_;
+}
+const ::proto::SyncActionValue_PrimaryVersionAction&
+SyncActionValue::_Internal::primaryversionaction(const SyncActionValue* msg) {
+  return *msg->_impl_.primaryversionaction_;
+}
+const ::proto::SyncActionValue_StickerAction&
+SyncActionValue::_Internal::stickeraction(const SyncActionValue* msg) {
+  return *msg->_impl_.stickeraction_;
+}
+SyncActionValue::SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue)
+}
+SyncActionValue::SyncActionValue(const SyncActionValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncActionValue* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.staraction_){nullptr}
+    , decltype(_impl_.contactaction_){nullptr}
+    , decltype(_impl_.muteaction_){nullptr}
+    , decltype(_impl_.pinaction_){nullptr}
+    , decltype(_impl_.securitynotificationsetting_){nullptr}
+    , decltype(_impl_.pushnamesetting_){nullptr}
+    , decltype(_impl_.quickreplyaction_){nullptr}
+    , decltype(_impl_.recentemojiweightsaction_){nullptr}
+    , decltype(_impl_.labeleditaction_){nullptr}
+    , decltype(_impl_.labelassociationaction_){nullptr}
+    , decltype(_impl_.localesetting_){nullptr}
+    , decltype(_impl_.archivechataction_){nullptr}
+    , decltype(_impl_.deletemessageformeaction_){nullptr}
+    , decltype(_impl_.keyexpiration_){nullptr}
+    , decltype(_impl_.markchatasreadaction_){nullptr}
+    , decltype(_impl_.clearchataction_){nullptr}
+    , decltype(_impl_.deletechataction_){nullptr}
+    , decltype(_impl_.unarchivechatssetting_){nullptr}
+    , decltype(_impl_.primaryfeature_){nullptr}
+    , decltype(_impl_.androidunsupportedactions_){nullptr}
+    , decltype(_impl_.agentaction_){nullptr}
+    , decltype(_impl_.subscriptionaction_){nullptr}
+    , decltype(_impl_.userstatusmuteaction_){nullptr}
+    , decltype(_impl_.timeformataction_){nullptr}
+    , decltype(_impl_.nuxaction_){nullptr}
+    , decltype(_impl_.primaryversionaction_){nullptr}
+    , decltype(_impl_.stickeraction_){nullptr}
+    , decltype(_impl_.timestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_staraction()) {
+    _this->_impl_.staraction_ = new ::proto::SyncActionValue_StarAction(*from._impl_.staraction_);
+  }
+  if (from._internal_has_contactaction()) {
+    _this->_impl_.contactaction_ = new ::proto::SyncActionValue_ContactAction(*from._impl_.contactaction_);
+  }
+  if (from._internal_has_muteaction()) {
+    _this->_impl_.muteaction_ = new ::proto::SyncActionValue_MuteAction(*from._impl_.muteaction_);
+  }
+  if (from._internal_has_pinaction()) {
+    _this->_impl_.pinaction_ = new ::proto::SyncActionValue_PinAction(*from._impl_.pinaction_);
+  }
+  if (from._internal_has_securitynotificationsetting()) {
+    _this->_impl_.securitynotificationsetting_ = new ::proto::SyncActionValue_SecurityNotificationSetting(*from._impl_.securitynotificationsetting_);
+  }
+  if (from._internal_has_pushnamesetting()) {
+    _this->_impl_.pushnamesetting_ = new ::proto::SyncActionValue_PushNameSetting(*from._impl_.pushnamesetting_);
+  }
+  if (from._internal_has_quickreplyaction()) {
+    _this->_impl_.quickreplyaction_ = new ::proto::SyncActionValue_QuickReplyAction(*from._impl_.quickreplyaction_);
+  }
+  if (from._internal_has_recentemojiweightsaction()) {
+    _this->_impl_.recentemojiweightsaction_ = new ::proto::SyncActionValue_RecentEmojiWeightsAction(*from._impl_.recentemojiweightsaction_);
+  }
+  if (from._internal_has_labeleditaction()) {
+    _this->_impl_.labeleditaction_ = new ::proto::SyncActionValue_LabelEditAction(*from._impl_.labeleditaction_);
+  }
+  if (from._internal_has_labelassociationaction()) {
+    _this->_impl_.labelassociationaction_ = new ::proto::SyncActionValue_LabelAssociationAction(*from._impl_.labelassociationaction_);
+  }
+  if (from._internal_has_localesetting()) {
+    _this->_impl_.localesetting_ = new ::proto::SyncActionValue_LocaleSetting(*from._impl_.localesetting_);
+  }
+  if (from._internal_has_archivechataction()) {
+    _this->_impl_.archivechataction_ = new ::proto::SyncActionValue_ArchiveChatAction(*from._impl_.archivechataction_);
+  }
+  if (from._internal_has_deletemessageformeaction()) {
+    _this->_impl_.deletemessageformeaction_ = new ::proto::SyncActionValue_DeleteMessageForMeAction(*from._impl_.deletemessageformeaction_);
+  }
+  if (from._internal_has_keyexpiration()) {
+    _this->_impl_.keyexpiration_ = new ::proto::SyncActionValue_KeyExpiration(*from._impl_.keyexpiration_);
+  }
+  if (from._internal_has_markchatasreadaction()) {
+    _this->_impl_.markchatasreadaction_ = new ::proto::SyncActionValue_MarkChatAsReadAction(*from._impl_.markchatasreadaction_);
+  }
+  if (from._internal_has_clearchataction()) {
+    _this->_impl_.clearchataction_ = new ::proto::SyncActionValue_ClearChatAction(*from._impl_.clearchataction_);
+  }
+  if (from._internal_has_deletechataction()) {
+    _this->_impl_.deletechataction_ = new ::proto::SyncActionValue_DeleteChatAction(*from._impl_.deletechataction_);
+  }
+  if (from._internal_has_unarchivechatssetting()) {
+    _this->_impl_.unarchivechatssetting_ = new ::proto::SyncActionValue_UnarchiveChatsSetting(*from._impl_.unarchivechatssetting_);
+  }
+  if (from._internal_has_primaryfeature()) {
+    _this->_impl_.primaryfeature_ = new ::proto::SyncActionValue_PrimaryFeature(*from._impl_.primaryfeature_);
+  }
+  if (from._internal_has_androidunsupportedactions()) {
+    _this->_impl_.androidunsupportedactions_ = new ::proto::SyncActionValue_AndroidUnsupportedActions(*from._impl_.androidunsupportedactions_);
+  }
+  if (from._internal_has_agentaction()) {
+    _this->_impl_.agentaction_ = new ::proto::SyncActionValue_AgentAction(*from._impl_.agentaction_);
+  }
+  if (from._internal_has_subscriptionaction()) {
+    _this->_impl_.subscriptionaction_ = new ::proto::SyncActionValue_SubscriptionAction(*from._impl_.subscriptionaction_);
+  }
+  if (from._internal_has_userstatusmuteaction()) {
+    _this->_impl_.userstatusmuteaction_ = new ::proto::SyncActionValue_UserStatusMuteAction(*from._impl_.userstatusmuteaction_);
+  }
+  if (from._internal_has_timeformataction()) {
+    _this->_impl_.timeformataction_ = new ::proto::SyncActionValue_TimeFormatAction(*from._impl_.timeformataction_);
+  }
+  if (from._internal_has_nuxaction()) {
+    _this->_impl_.nuxaction_ = new ::proto::SyncActionValue_NuxAction(*from._impl_.nuxaction_);
+  }
+  if (from._internal_has_primaryversionaction()) {
+    _this->_impl_.primaryversionaction_ = new ::proto::SyncActionValue_PrimaryVersionAction(*from._impl_.primaryversionaction_);
+  }
+  if (from._internal_has_stickeraction()) {
+    _this->_impl_.stickeraction_ = new ::proto::SyncActionValue_StickerAction(*from._impl_.stickeraction_);
+  }
+  _this->_impl_.timestamp_ = from._impl_.timestamp_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue)
+}
+
+inline void SyncActionValue::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.staraction_){nullptr}
+    , decltype(_impl_.contactaction_){nullptr}
+    , decltype(_impl_.muteaction_){nullptr}
+    , decltype(_impl_.pinaction_){nullptr}
+    , decltype(_impl_.securitynotificationsetting_){nullptr}
+    , decltype(_impl_.pushnamesetting_){nullptr}
+    , decltype(_impl_.quickreplyaction_){nullptr}
+    , decltype(_impl_.recentemojiweightsaction_){nullptr}
+    , decltype(_impl_.labeleditaction_){nullptr}
+    , decltype(_impl_.labelassociationaction_){nullptr}
+    , decltype(_impl_.localesetting_){nullptr}
+    , decltype(_impl_.archivechataction_){nullptr}
+    , decltype(_impl_.deletemessageformeaction_){nullptr}
+    , decltype(_impl_.keyexpiration_){nullptr}
+    , decltype(_impl_.markchatasreadaction_){nullptr}
+    , decltype(_impl_.clearchataction_){nullptr}
+    , decltype(_impl_.deletechataction_){nullptr}
+    , decltype(_impl_.unarchivechatssetting_){nullptr}
+    , decltype(_impl_.primaryfeature_){nullptr}
+    , decltype(_impl_.androidunsupportedactions_){nullptr}
+    , decltype(_impl_.agentaction_){nullptr}
+    , decltype(_impl_.subscriptionaction_){nullptr}
+    , decltype(_impl_.userstatusmuteaction_){nullptr}
+    , decltype(_impl_.timeformataction_){nullptr}
+    , decltype(_impl_.nuxaction_){nullptr}
+    , decltype(_impl_.primaryversionaction_){nullptr}
+    , decltype(_impl_.stickeraction_){nullptr}
+    , decltype(_impl_.timestamp_){int64_t{0}}
+  };
+}
+
+SyncActionValue::~SyncActionValue() {
+  // @@protoc_insertion_point(destructor:proto.SyncActionValue)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncActionValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.staraction_;
+  if (this != internal_default_instance()) delete _impl_.contactaction_;
+  if (this != internal_default_instance()) delete _impl_.muteaction_;
+  if (this != internal_default_instance()) delete _impl_.pinaction_;
+  if (this != internal_default_instance()) delete _impl_.securitynotificationsetting_;
+  if (this != internal_default_instance()) delete _impl_.pushnamesetting_;
+  if (this != internal_default_instance()) delete _impl_.quickreplyaction_;
+  if (this != internal_default_instance()) delete _impl_.recentemojiweightsaction_;
+  if (this != internal_default_instance()) delete _impl_.labeleditaction_;
+  if (this != internal_default_instance()) delete _impl_.labelassociationaction_;
+  if (this != internal_default_instance()) delete _impl_.localesetting_;
+  if (this != internal_default_instance()) delete _impl_.archivechataction_;
+  if (this != internal_default_instance()) delete _impl_.deletemessageformeaction_;
+  if (this != internal_default_instance()) delete _impl_.keyexpiration_;
+  if (this != internal_default_instance()) delete _impl_.markchatasreadaction_;
+  if (this != internal_default_instance()) delete _impl_.clearchataction_;
+  if (this != internal_default_instance()) delete _impl_.deletechataction_;
+  if (this != internal_default_instance()) delete _impl_.unarchivechatssetting_;
+  if (this != internal_default_instance()) delete _impl_.primaryfeature_;
+  if (this != internal_default_instance()) delete _impl_.androidunsupportedactions_;
+  if (this != internal_default_instance()) delete _impl_.agentaction_;
+  if (this != internal_default_instance()) delete _impl_.subscriptionaction_;
+  if (this != internal_default_instance()) delete _impl_.userstatusmuteaction_;
+  if (this != internal_default_instance()) delete _impl_.timeformataction_;
+  if (this != internal_default_instance()) delete _impl_.nuxaction_;
+  if (this != internal_default_instance()) delete _impl_.primaryversionaction_;
+  if (this != internal_default_instance()) delete _impl_.stickeraction_;
+}
+
+void SyncActionValue::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncActionValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.staraction_ != nullptr);
+      _impl_.staraction_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.contactaction_ != nullptr);
+      _impl_.contactaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.muteaction_ != nullptr);
+      _impl_.muteaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.pinaction_ != nullptr);
+      _impl_.pinaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.securitynotificationsetting_ != nullptr);
+      _impl_.securitynotificationsetting_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.pushnamesetting_ != nullptr);
+      _impl_.pushnamesetting_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.quickreplyaction_ != nullptr);
+      _impl_.quickreplyaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.recentemojiweightsaction_ != nullptr);
+      _impl_.recentemojiweightsaction_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      GOOGLE_DCHECK(_impl_.labeleditaction_ != nullptr);
+      _impl_.labeleditaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      GOOGLE_DCHECK(_impl_.labelassociationaction_ != nullptr);
+      _impl_.labelassociationaction_->Clear();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.localesetting_ != nullptr);
+      _impl_.localesetting_->Clear();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      GOOGLE_DCHECK(_impl_.archivechataction_ != nullptr);
+      _impl_.archivechataction_->Clear();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.deletemessageformeaction_ != nullptr);
+      _impl_.deletemessageformeaction_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.keyexpiration_ != nullptr);
+      _impl_.keyexpiration_->Clear();
+    }
+    if (cached_has_bits & 0x00004000u) {
+      GOOGLE_DCHECK(_impl_.markchatasreadaction_ != nullptr);
+      _impl_.markchatasreadaction_->Clear();
+    }
+    if (cached_has_bits & 0x00008000u) {
+      GOOGLE_DCHECK(_impl_.clearchataction_ != nullptr);
+      _impl_.clearchataction_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      GOOGLE_DCHECK(_impl_.deletechataction_ != nullptr);
+      _impl_.deletechataction_->Clear();
+    }
+    if (cached_has_bits & 0x00020000u) {
+      GOOGLE_DCHECK(_impl_.unarchivechatssetting_ != nullptr);
+      _impl_.unarchivechatssetting_->Clear();
+    }
+    if (cached_has_bits & 0x00040000u) {
+      GOOGLE_DCHECK(_impl_.primaryfeature_ != nullptr);
+      _impl_.primaryfeature_->Clear();
+    }
+    if (cached_has_bits & 0x00080000u) {
+      GOOGLE_DCHECK(_impl_.androidunsupportedactions_ != nullptr);
+      _impl_.androidunsupportedactions_->Clear();
+    }
+    if (cached_has_bits & 0x00100000u) {
+      GOOGLE_DCHECK(_impl_.agentaction_ != nullptr);
+      _impl_.agentaction_->Clear();
+    }
+    if (cached_has_bits & 0x00200000u) {
+      GOOGLE_DCHECK(_impl_.subscriptionaction_ != nullptr);
+      _impl_.subscriptionaction_->Clear();
+    }
+    if (cached_has_bits & 0x00400000u) {
+      GOOGLE_DCHECK(_impl_.userstatusmuteaction_ != nullptr);
+      _impl_.userstatusmuteaction_->Clear();
+    }
+    if (cached_has_bits & 0x00800000u) {
+      GOOGLE_DCHECK(_impl_.timeformataction_ != nullptr);
+      _impl_.timeformataction_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x07000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      GOOGLE_DCHECK(_impl_.nuxaction_ != nullptr);
+      _impl_.nuxaction_->Clear();
+    }
+    if (cached_has_bits & 0x02000000u) {
+      GOOGLE_DCHECK(_impl_.primaryversionaction_ != nullptr);
+      _impl_.primaryversionaction_->Clear();
+    }
+    if (cached_has_bits & 0x04000000u) {
+      GOOGLE_DCHECK(_impl_.stickeraction_ != nullptr);
+      _impl_.stickeraction_->Clear();
+    }
+  }
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncActionValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int64 timestamp = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.StarAction starAction = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_staraction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.ContactAction contactAction = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_contactaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.MuteAction muteAction = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_muteaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.PinAction pinAction = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pinaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_securitynotificationsetting(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pushnamesetting(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quickreplyaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_recentemojiweightsaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_labeleditaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr = ctx->ParseMessage(_internal_mutable_labelassociationaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_localesetting(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_archivechataction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr = ctx->ParseMessage(_internal_mutable_deletemessageformeaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keyexpiration(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr = ctx->ParseMessage(_internal_mutable_markchatasreadaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          ptr = ctx->ParseMessage(_internal_mutable_clearchataction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_deletechataction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_unarchivechatssetting(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_primaryfeature(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          ptr = ctx->ParseMessage(_internal_mutable_androidunsupportedactions(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.AgentAction agentAction = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          ptr = ctx->ParseMessage(_internal_mutable_agentaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_subscriptionaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_userstatusmuteaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timeformataction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.NuxAction nuxAction = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 250)) {
+          ptr = ctx->ParseMessage(_internal_mutable_nuxaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_primaryversionaction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncActionValue.StickerAction stickerAction = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_stickeraction(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncActionValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 timestamp = 1;
+  if (cached_has_bits & 0x08000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target);
+  }
+
+  // optional .proto.SyncActionValue.StarAction starAction = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::staraction(this),
+        _Internal::staraction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.ContactAction contactAction = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::contactaction(this),
+        _Internal::contactaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.MuteAction muteAction = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::muteaction(this),
+        _Internal::muteaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.PinAction pinAction = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::pinaction(this),
+        _Internal::pinaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::securitynotificationsetting(this),
+        _Internal::securitynotificationsetting(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::pushnamesetting(this),
+        _Internal::pushnamesetting(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::quickreplyaction(this),
+        _Internal::quickreplyaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(11, _Internal::recentemojiweightsaction(this),
+        _Internal::recentemojiweightsaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(14, _Internal::labeleditaction(this),
+        _Internal::labeleditaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
+  if (cached_has_bits & 0x00000200u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, _Internal::labelassociationaction(this),
+        _Internal::labelassociationaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(16, _Internal::localesetting(this),
+        _Internal::localesetting(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
+  if (cached_has_bits & 0x00000800u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::archivechataction(this),
+        _Internal::archivechataction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(18, _Internal::deletemessageformeaction(this),
+        _Internal::deletemessageformeaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(19, _Internal::keyexpiration(this),
+        _Internal::keyexpiration(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
+  if (cached_has_bits & 0x00004000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(20, _Internal::markchatasreadaction(this),
+        _Internal::markchatasreadaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
+  if (cached_has_bits & 0x00008000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(21, _Internal::clearchataction(this),
+        _Internal::clearchataction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
+  if (cached_has_bits & 0x00010000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(22, _Internal::deletechataction(this),
+        _Internal::deletechataction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
+  if (cached_has_bits & 0x00020000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(23, _Internal::unarchivechatssetting(this),
+        _Internal::unarchivechatssetting(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
+  if (cached_has_bits & 0x00040000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(24, _Internal::primaryfeature(this),
+        _Internal::primaryfeature(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
+  if (cached_has_bits & 0x00080000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(26, _Internal::androidunsupportedactions(this),
+        _Internal::androidunsupportedactions(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.AgentAction agentAction = 27;
+  if (cached_has_bits & 0x00100000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(27, _Internal::agentaction(this),
+        _Internal::agentaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
+  if (cached_has_bits & 0x00200000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(28, _Internal::subscriptionaction(this),
+        _Internal::subscriptionaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
+  if (cached_has_bits & 0x00400000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(29, _Internal::userstatusmuteaction(this),
+        _Internal::userstatusmuteaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
+  if (cached_has_bits & 0x00800000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(30, _Internal::timeformataction(this),
+        _Internal::timeformataction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.NuxAction nuxAction = 31;
+  if (cached_has_bits & 0x01000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(31, _Internal::nuxaction(this),
+        _Internal::nuxaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
+  if (cached_has_bits & 0x02000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(32, _Internal::primaryversionaction(this),
+        _Internal::primaryversionaction(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncActionValue.StickerAction stickerAction = 33;
+  if (cached_has_bits & 0x04000000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(33, _Internal::stickeraction(this),
+        _Internal::stickeraction(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncActionValue)
+  return target;
+}
+
+size_t SyncActionValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.SyncActionValue.StarAction starAction = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.staraction_);
+    }
+
+    // optional .proto.SyncActionValue.ContactAction contactAction = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.contactaction_);
+    }
+
+    // optional .proto.SyncActionValue.MuteAction muteAction = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.muteaction_);
+    }
+
+    // optional .proto.SyncActionValue.PinAction pinAction = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pinaction_);
+    }
+
+    // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.securitynotificationsetting_);
+    }
+
+    // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.pushnamesetting_);
+    }
+
+    // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quickreplyaction_);
+    }
+
+    // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.recentemojiweightsaction_);
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.labeleditaction_);
+    }
+
+    // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.labelassociationaction_);
+    }
+
+    // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.localesetting_);
+    }
+
+    // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.archivechataction_);
+    }
+
+    // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.deletemessageformeaction_);
+    }
+
+    // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keyexpiration_);
+    }
+
+    // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.markchatasreadaction_);
+    }
+
+    // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.clearchataction_);
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.deletechataction_);
+    }
+
+    // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.unarchivechatssetting_);
+    }
+
+    // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.primaryfeature_);
+    }
+
+    // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.androidunsupportedactions_);
+    }
+
+    // optional .proto.SyncActionValue.AgentAction agentAction = 27;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.agentaction_);
+    }
+
+    // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.subscriptionaction_);
+    }
+
+    // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.userstatusmuteaction_);
+    }
+
+    // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.timeformataction_);
+    }
+
+  }
+  if (cached_has_bits & 0x0f000000u) {
+    // optional .proto.SyncActionValue.NuxAction nuxAction = 31;
+    if (cached_has_bits & 0x01000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.nuxaction_);
+    }
+
+    // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
+    if (cached_has_bits & 0x02000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.primaryversionaction_);
+    }
+
+    // optional .proto.SyncActionValue.StickerAction stickerAction = 33;
+    if (cached_has_bits & 0x04000000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.stickeraction_);
+    }
+
+    // optional int64 timestamp = 1;
+    if (cached_has_bits & 0x08000000u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncActionValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue::GetClassData() const { return &_class_data_; }
+
+
+void SyncActionValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncActionValue*>(&to_msg);
+  auto& from = static_cast<const SyncActionValue&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_staraction()->::proto::SyncActionValue_StarAction::MergeFrom(
+          from._internal_staraction());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_contactaction()->::proto::SyncActionValue_ContactAction::MergeFrom(
+          from._internal_contactaction());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_muteaction()->::proto::SyncActionValue_MuteAction::MergeFrom(
+          from._internal_muteaction());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_pinaction()->::proto::SyncActionValue_PinAction::MergeFrom(
+          from._internal_pinaction());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_securitynotificationsetting()->::proto::SyncActionValue_SecurityNotificationSetting::MergeFrom(
+          from._internal_securitynotificationsetting());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_pushnamesetting()->::proto::SyncActionValue_PushNameSetting::MergeFrom(
+          from._internal_pushnamesetting());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_quickreplyaction()->::proto::SyncActionValue_QuickReplyAction::MergeFrom(
+          from._internal_quickreplyaction());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_recentemojiweightsaction()->::proto::SyncActionValue_RecentEmojiWeightsAction::MergeFrom(
+          from._internal_recentemojiweightsaction());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_labeleditaction()->::proto::SyncActionValue_LabelEditAction::MergeFrom(
+          from._internal_labeleditaction());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_mutable_labelassociationaction()->::proto::SyncActionValue_LabelAssociationAction::MergeFrom(
+          from._internal_labelassociationaction());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_localesetting()->::proto::SyncActionValue_LocaleSetting::MergeFrom(
+          from._internal_localesetting());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_mutable_archivechataction()->::proto::SyncActionValue_ArchiveChatAction::MergeFrom(
+          from._internal_archivechataction());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_deletemessageformeaction()->::proto::SyncActionValue_DeleteMessageForMeAction::MergeFrom(
+          from._internal_deletemessageformeaction());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_keyexpiration()->::proto::SyncActionValue_KeyExpiration::MergeFrom(
+          from._internal_keyexpiration());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_internal_mutable_markchatasreadaction()->::proto::SyncActionValue_MarkChatAsReadAction::MergeFrom(
+          from._internal_markchatasreadaction());
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_internal_mutable_clearchataction()->::proto::SyncActionValue_ClearChatAction::MergeFrom(
+          from._internal_clearchataction());
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_internal_mutable_deletechataction()->::proto::SyncActionValue_DeleteChatAction::MergeFrom(
+          from._internal_deletechataction());
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_internal_mutable_unarchivechatssetting()->::proto::SyncActionValue_UnarchiveChatsSetting::MergeFrom(
+          from._internal_unarchivechatssetting());
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_internal_mutable_primaryfeature()->::proto::SyncActionValue_PrimaryFeature::MergeFrom(
+          from._internal_primaryfeature());
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_internal_mutable_androidunsupportedactions()->::proto::SyncActionValue_AndroidUnsupportedActions::MergeFrom(
+          from._internal_androidunsupportedactions());
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_internal_mutable_agentaction()->::proto::SyncActionValue_AgentAction::MergeFrom(
+          from._internal_agentaction());
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_internal_mutable_subscriptionaction()->::proto::SyncActionValue_SubscriptionAction::MergeFrom(
+          from._internal_subscriptionaction());
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_internal_mutable_userstatusmuteaction()->::proto::SyncActionValue_UserStatusMuteAction::MergeFrom(
+          from._internal_userstatusmuteaction());
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_internal_mutable_timeformataction()->::proto::SyncActionValue_TimeFormatAction::MergeFrom(
+          from._internal_timeformataction());
+    }
+  }
+  if (cached_has_bits & 0x0f000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      _this->_internal_mutable_nuxaction()->::proto::SyncActionValue_NuxAction::MergeFrom(
+          from._internal_nuxaction());
+    }
+    if (cached_has_bits & 0x02000000u) {
+      _this->_internal_mutable_primaryversionaction()->::proto::SyncActionValue_PrimaryVersionAction::MergeFrom(
+          from._internal_primaryversionaction());
+    }
+    if (cached_has_bits & 0x04000000u) {
+      _this->_internal_mutable_stickeraction()->::proto::SyncActionValue_StickerAction::MergeFrom(
+          from._internal_stickeraction());
+    }
+    if (cached_has_bits & 0x08000000u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncActionValue::CopyFrom(const SyncActionValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncActionValue::IsInitialized() const {
+  return true;
+}
+
+void SyncActionValue::InternalSwap(SyncActionValue* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.timestamp_)
+      + sizeof(SyncActionValue::_impl_.timestamp_)
+      - PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.staraction_)>(
+          reinterpret_cast<char*>(&_impl_.staraction_),
+          reinterpret_cast<char*>(&other->_impl_.staraction_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[204]);
+}
+
+// ===================================================================
+
+class SyncdIndex::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdIndex>()._impl_._has_bits_);
+  static void set_has_blob(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncdIndex::SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdIndex)
+}
+SyncdIndex::SyncdIndex(const SyncdIndex& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdIndex* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.blob_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.blob_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_blob()) {
+    _this->_impl_.blob_.Set(from._internal_blob(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdIndex)
+}
+
+inline void SyncdIndex::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.blob_){}
+  };
+  _impl_.blob_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncdIndex::~SyncdIndex() {
+  // @@protoc_insertion_point(destructor:proto.SyncdIndex)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdIndex::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.blob_.Destroy();
+}
+
+void SyncdIndex::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdIndex::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdIndex)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.blob_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdIndex::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes blob = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_blob();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdIndex::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdIndex)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes blob = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_blob(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdIndex)
+  return target;
+}
+
+size_t SyncdIndex::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdIndex)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes blob = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_blob());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdIndex::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdIndex::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdIndex::GetClassData() const { return &_class_data_; }
+
+
+void SyncdIndex::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdIndex*>(&to_msg);
+  auto& from = static_cast<const SyncdIndex&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdIndex)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_blob()) {
+    _this->_internal_set_blob(from._internal_blob());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdIndex::CopyFrom(const SyncdIndex& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdIndex)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdIndex::IsInitialized() const {
+  return true;
+}
+
+void SyncdIndex::InternalSwap(SyncdIndex* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.blob_, lhs_arena,
+      &other->_impl_.blob_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdIndex::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[205]);
+}
+
+// ===================================================================
+
+class SyncdMutation::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdMutation>()._impl_._has_bits_);
+  static void set_has_operation(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::SyncdRecord& record(const SyncdMutation* msg);
+  static void set_has_record(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::SyncdRecord&
+SyncdMutation::_Internal::record(const SyncdMutation* msg) {
+  return *msg->_impl_.record_;
+}
+SyncdMutation::SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdMutation)
+}
+SyncdMutation::SyncdMutation(const SyncdMutation& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdMutation* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.record_){nullptr}
+    , decltype(_impl_.operation_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_record()) {
+    _this->_impl_.record_ = new ::proto::SyncdRecord(*from._impl_.record_);
+  }
+  _this->_impl_.operation_ = from._impl_.operation_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdMutation)
+}
+
+inline void SyncdMutation::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.record_){nullptr}
+    , decltype(_impl_.operation_){0}
+  };
+}
+
+SyncdMutation::~SyncdMutation() {
+  // @@protoc_insertion_point(destructor:proto.SyncdMutation)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdMutation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.record_;
+}
+
+void SyncdMutation::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdMutation::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdMutation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.record_ != nullptr);
+    _impl_.record_->Clear();
+  }
+  _impl_.operation_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdMutation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncdMutation.SyncdOperation operation = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::SyncdMutation_SyncdOperation_IsValid(val))) {
+            _internal_set_operation(static_cast<::proto::SyncdMutation_SyncdOperation>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncdRecord record = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_record(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdMutation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncdMutation.SyncdOperation operation = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_operation(), target);
+  }
+
+  // optional .proto.SyncdRecord record = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::record(this),
+        _Internal::record(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdMutation)
+  return target;
+}
+
+size_t SyncdMutation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.SyncdRecord record = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.record_);
+    }
+
+    // optional .proto.SyncdMutation.SyncdOperation operation = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_operation());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutation::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdMutation::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutation::GetClassData() const { return &_class_data_; }
+
+
+void SyncdMutation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdMutation*>(&to_msg);
+  auto& from = static_cast<const SyncdMutation&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutation)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_record()->::proto::SyncdRecord::MergeFrom(
+          from._internal_record());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.operation_ = from._impl_.operation_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdMutation::CopyFrom(const SyncdMutation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdMutation::IsInitialized() const {
+  return true;
+}
+
+void SyncdMutation::InternalSwap(SyncdMutation* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.operation_)
+      + sizeof(SyncdMutation::_impl_.operation_)
+      - PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.record_)>(
+          reinterpret_cast<char*>(&_impl_.record_),
+          reinterpret_cast<char*>(&other->_impl_.record_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutation::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[206]);
+}
+
+// ===================================================================
+
+class SyncdMutations::_Internal {
+ public:
+};
+
+SyncdMutations::SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdMutations)
+}
+SyncdMutations::SyncdMutations(const SyncdMutations& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdMutations* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.mutations_){from._impl_.mutations_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdMutations)
+}
+
+inline void SyncdMutations::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.mutations_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+SyncdMutations::~SyncdMutations() {
+  // @@protoc_insertion_point(destructor:proto.SyncdMutations)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdMutations::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mutations_.~RepeatedPtrField();
+}
+
+void SyncdMutations::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdMutations::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdMutations)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.mutations_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdMutations::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .proto.SyncdMutation mutations = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_mutations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdMutations::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutations)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .proto.SyncdMutation mutations = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_mutations_size()); i < n; i++) {
+    const auto& repfield = this->_internal_mutations(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdMutations)
+  return target;
+}
+
+size_t SyncdMutations::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutations)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SyncdMutation mutations = 1;
+  total_size += 1UL * this->_internal_mutations_size();
+  for (const auto& msg : this->_impl_.mutations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutations::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdMutations::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutations::GetClassData() const { return &_class_data_; }
+
+
+void SyncdMutations::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdMutations*>(&to_msg);
+  auto& from = static_cast<const SyncdMutations&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutations)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdMutations::CopyFrom(const SyncdMutations& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutations)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdMutations::IsInitialized() const {
+  return true;
+}
+
+void SyncdMutations::InternalSwap(SyncdMutations* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.mutations_.InternalSwap(&other->_impl_.mutations_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutations::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[207]);
+}
+
+// ===================================================================
+
+class SyncdPatch::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdPatch>()._impl_._has_bits_);
+  static const ::proto::SyncdVersion& version(const SyncdPatch* msg);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::proto::ExternalBlobReference& externalmutations(const SyncdPatch* msg);
+  static void set_has_externalmutations(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_snapshotmac(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_patchmac(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::KeyId& keyid(const SyncdPatch* msg);
+  static void set_has_keyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::ExitCode& exitcode(const SyncdPatch* msg);
+  static void set_has_exitcode(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_deviceindex(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+};
+
+const ::proto::SyncdVersion&
+SyncdPatch::_Internal::version(const SyncdPatch* msg) {
+  return *msg->_impl_.version_;
+}
+const ::proto::ExternalBlobReference&
+SyncdPatch::_Internal::externalmutations(const SyncdPatch* msg) {
+  return *msg->_impl_.externalmutations_;
+}
+const ::proto::KeyId&
+SyncdPatch::_Internal::keyid(const SyncdPatch* msg) {
+  return *msg->_impl_.keyid_;
+}
+const ::proto::ExitCode&
+SyncdPatch::_Internal::exitcode(const SyncdPatch* msg) {
+  return *msg->_impl_.exitcode_;
+}
+SyncdPatch::SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdPatch)
+}
+SyncdPatch::SyncdPatch(const SyncdPatch& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdPatch* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mutations_){from._impl_.mutations_}
+    , decltype(_impl_.snapshotmac_){}
+    , decltype(_impl_.patchmac_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.externalmutations_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}
+    , decltype(_impl_.exitcode_){nullptr}
+    , decltype(_impl_.deviceindex_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.snapshotmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_snapshotmac()) {
+    _this->_impl_.snapshotmac_.Set(from._internal_snapshotmac(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.patchmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.patchmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_patchmac()) {
+    _this->_impl_.patchmac_.Set(from._internal_patchmac(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_version()) {
+    _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_);
+  }
+  if (from._internal_has_externalmutations()) {
+    _this->_impl_.externalmutations_ = new ::proto::ExternalBlobReference(*from._impl_.externalmutations_);
+  }
+  if (from._internal_has_keyid()) {
+    _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_);
+  }
+  if (from._internal_has_exitcode()) {
+    _this->_impl_.exitcode_ = new ::proto::ExitCode(*from._impl_.exitcode_);
+  }
+  _this->_impl_.deviceindex_ = from._impl_.deviceindex_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdPatch)
+}
+
+inline void SyncdPatch::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mutations_){arena}
+    , decltype(_impl_.snapshotmac_){}
+    , decltype(_impl_.patchmac_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.externalmutations_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}
+    , decltype(_impl_.exitcode_){nullptr}
+    , decltype(_impl_.deviceindex_){0u}
+  };
+  _impl_.snapshotmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.patchmac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.patchmac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncdPatch::~SyncdPatch() {
+  // @@protoc_insertion_point(destructor:proto.SyncdPatch)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdPatch::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mutations_.~RepeatedPtrField();
+  _impl_.snapshotmac_.Destroy();
+  _impl_.patchmac_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.version_;
+  if (this != internal_default_instance()) delete _impl_.externalmutations_;
+  if (this != internal_default_instance()) delete _impl_.keyid_;
+  if (this != internal_default_instance()) delete _impl_.exitcode_;
+}
+
+void SyncdPatch::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdPatch::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdPatch)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.mutations_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.snapshotmac_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.patchmac_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.version_ != nullptr);
+      _impl_.version_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.externalmutations_ != nullptr);
+      _impl_.externalmutations_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.keyid_ != nullptr);
+      _impl_.keyid_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.exitcode_ != nullptr);
+      _impl_.exitcode_->Clear();
+    }
+  }
+  _impl_.deviceindex_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdPatch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncdVersion version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.SyncdMutation mutations = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_mutations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ExternalBlobReference externalMutations = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_externalmutations(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes snapshotMac = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_snapshotmac();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes patchMac = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_patchmac();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.KeyId keyId = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.ExitCode exitCode = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_exitcode(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 deviceIndex = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_deviceindex(&has_bits);
+          _impl_.deviceindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdPatch::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdPatch)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncdVersion version = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::version(this),
+        _Internal::version(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.SyncdMutation mutations = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_mutations_size()); i < n; i++) {
+    const auto& repfield = this->_internal_mutations(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ExternalBlobReference externalMutations = 3;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::externalmutations(this),
+        _Internal::externalmutations(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes snapshotMac = 4;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_snapshotmac(), target);
+  }
+
+  // optional bytes patchMac = 5;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_patchmac(), target);
+  }
+
+  // optional .proto.KeyId keyId = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::keyid(this),
+        _Internal::keyid(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.ExitCode exitCode = 7;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::exitcode(this),
+        _Internal::exitcode(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 deviceIndex = 8;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_deviceindex(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdPatch)
+  return target;
+}
+
+size_t SyncdPatch::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdPatch)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SyncdMutation mutations = 2;
+  total_size += 1UL * this->_internal_mutations_size();
+  for (const auto& msg : this->_impl_.mutations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional bytes snapshotMac = 4;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_snapshotmac());
+    }
+
+    // optional bytes patchMac = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_patchmac());
+    }
+
+    // optional .proto.SyncdVersion version = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.version_);
+    }
+
+    // optional .proto.ExternalBlobReference externalMutations = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.externalmutations_);
+    }
+
+    // optional .proto.KeyId keyId = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keyid_);
+    }
+
+    // optional .proto.ExitCode exitCode = 7;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.exitcode_);
+    }
+
+    // optional uint32 deviceIndex = 8;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceindex());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdPatch::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdPatch::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdPatch::GetClassData() const { return &_class_data_; }
+
+
+void SyncdPatch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdPatch*>(&to_msg);
+  auto& from = static_cast<const SyncdPatch&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdPatch)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_snapshotmac(from._internal_snapshotmac());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_patchmac(from._internal_patchmac());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom(
+          from._internal_version());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_externalmutations()->::proto::ExternalBlobReference::MergeFrom(
+          from._internal_externalmutations());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom(
+          from._internal_keyid());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_exitcode()->::proto::ExitCode::MergeFrom(
+          from._internal_exitcode());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.deviceindex_ = from._impl_.deviceindex_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdPatch::CopyFrom(const SyncdPatch& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdPatch)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdPatch::IsInitialized() const {
+  return true;
+}
+
+void SyncdPatch::InternalSwap(SyncdPatch* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.mutations_.InternalSwap(&other->_impl_.mutations_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.snapshotmac_, lhs_arena,
+      &other->_impl_.snapshotmac_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.patchmac_, lhs_arena,
+      &other->_impl_.patchmac_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.deviceindex_)
+      + sizeof(SyncdPatch::_impl_.deviceindex_)
+      - PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.version_)>(
+          reinterpret_cast<char*>(&_impl_.version_),
+          reinterpret_cast<char*>(&other->_impl_.version_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdPatch::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[208]);
+}
+
+// ===================================================================
+
+class SyncdRecord::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdRecord>()._impl_._has_bits_);
+  static const ::proto::SyncdIndex& index(const SyncdRecord* msg);
+  static void set_has_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::SyncdValue& value(const SyncdRecord* msg);
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::proto::KeyId& keyid(const SyncdRecord* msg);
+  static void set_has_keyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::SyncdIndex&
+SyncdRecord::_Internal::index(const SyncdRecord* msg) {
+  return *msg->_impl_.index_;
+}
+const ::proto::SyncdValue&
+SyncdRecord::_Internal::value(const SyncdRecord* msg) {
+  return *msg->_impl_.value_;
+}
+const ::proto::KeyId&
+SyncdRecord::_Internal::keyid(const SyncdRecord* msg) {
+  return *msg->_impl_.keyid_;
+}
+SyncdRecord::SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdRecord)
+}
+SyncdRecord::SyncdRecord(const SyncdRecord& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdRecord* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){nullptr}
+    , decltype(_impl_.value_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_index()) {
+    _this->_impl_.index_ = new ::proto::SyncdIndex(*from._impl_.index_);
+  }
+  if (from._internal_has_value()) {
+    _this->_impl_.value_ = new ::proto::SyncdValue(*from._impl_.value_);
+  }
+  if (from._internal_has_keyid()) {
+    _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdRecord)
+}
+
+inline void SyncdRecord::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){nullptr}
+    , decltype(_impl_.value_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}
+  };
+}
+
+SyncdRecord::~SyncdRecord() {
+  // @@protoc_insertion_point(destructor:proto.SyncdRecord)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdRecord::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.index_;
+  if (this != internal_default_instance()) delete _impl_.value_;
+  if (this != internal_default_instance()) delete _impl_.keyid_;
+}
+
+void SyncdRecord::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdRecord::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdRecord)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.index_ != nullptr);
+      _impl_.index_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.value_ != nullptr);
+      _impl_.value_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.keyid_ != nullptr);
+      _impl_.keyid_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncdIndex index = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_index(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.SyncdValue value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.KeyId keyId = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdRecord::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdRecord)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncdIndex index = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::index(this),
+        _Internal::index(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.SyncdValue value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::value(this),
+        _Internal::value(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.KeyId keyId = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::keyid(this),
+        _Internal::keyid(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdRecord)
+  return target;
+}
+
+size_t SyncdRecord::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdRecord)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .proto.SyncdIndex index = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.index_);
+    }
+
+    // optional .proto.SyncdValue value = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.value_);
+    }
+
+    // optional .proto.KeyId keyId = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keyid_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdRecord::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdRecord::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdRecord::GetClassData() const { return &_class_data_; }
+
+
+void SyncdRecord::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdRecord*>(&to_msg);
+  auto& from = static_cast<const SyncdRecord&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdRecord)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_index()->::proto::SyncdIndex::MergeFrom(
+          from._internal_index());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_value()->::proto::SyncdValue::MergeFrom(
+          from._internal_value());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom(
+          from._internal_keyid());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdRecord::CopyFrom(const SyncdRecord& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdRecord)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdRecord::IsInitialized() const {
+  return true;
+}
+
+void SyncdRecord::InternalSwap(SyncdRecord* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.keyid_)
+      + sizeof(SyncdRecord::_impl_.keyid_)
+      - PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.index_)>(
+          reinterpret_cast<char*>(&_impl_.index_),
+          reinterpret_cast<char*>(&other->_impl_.index_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdRecord::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[209]);
+}
+
+// ===================================================================
+
+class SyncdSnapshot::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdSnapshot>()._impl_._has_bits_);
+  static const ::proto::SyncdVersion& version(const SyncdSnapshot* msg);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_mac(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::KeyId& keyid(const SyncdSnapshot* msg);
+  static void set_has_keyid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::proto::SyncdVersion&
+SyncdSnapshot::_Internal::version(const SyncdSnapshot* msg) {
+  return *msg->_impl_.version_;
+}
+const ::proto::KeyId&
+SyncdSnapshot::_Internal::keyid(const SyncdSnapshot* msg) {
+  return *msg->_impl_.keyid_;
+}
+SyncdSnapshot::SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdSnapshot)
+}
+SyncdSnapshot::SyncdSnapshot(const SyncdSnapshot& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdSnapshot* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.records_){from._impl_.records_}
+    , decltype(_impl_.mac_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.mac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mac()) {
+    _this->_impl_.mac_.Set(from._internal_mac(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_version()) {
+    _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_);
+  }
+  if (from._internal_has_keyid()) {
+    _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdSnapshot)
+}
+
+inline void SyncdSnapshot::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.records_){arena}
+    , decltype(_impl_.mac_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.keyid_){nullptr}
+  };
+  _impl_.mac_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mac_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncdSnapshot::~SyncdSnapshot() {
+  // @@protoc_insertion_point(destructor:proto.SyncdSnapshot)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdSnapshot::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.records_.~RepeatedPtrField();
+  _impl_.mac_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.version_;
+  if (this != internal_default_instance()) delete _impl_.keyid_;
+}
+
+void SyncdSnapshot::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdSnapshot::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdSnapshot)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.records_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.mac_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.version_ != nullptr);
+      _impl_.version_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.keyid_ != nullptr);
+      _impl_.keyid_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.SyncdVersion version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.SyncdRecord records = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_records(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mac = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_mac();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.KeyId keyId = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdSnapshot::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdSnapshot)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.SyncdVersion version = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::version(this),
+        _Internal::version(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.SyncdRecord records = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_records_size()); i < n; i++) {
+    const auto& repfield = this->_internal_records(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bytes mac = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_mac(), target);
+  }
+
+  // optional .proto.KeyId keyId = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::keyid(this),
+        _Internal::keyid(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdSnapshot)
+  return target;
+}
+
+size_t SyncdSnapshot::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdSnapshot)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.SyncdRecord records = 2;
+  total_size += 1UL * this->_internal_records_size();
+  for (const auto& msg : this->_impl_.records_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes mac = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mac());
+    }
+
+    // optional .proto.SyncdVersion version = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.version_);
+    }
+
+    // optional .proto.KeyId keyId = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keyid_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdSnapshot::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdSnapshot::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdSnapshot::GetClassData() const { return &_class_data_; }
+
+
+void SyncdSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdSnapshot*>(&to_msg);
+  auto& from = static_cast<const SyncdSnapshot&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdSnapshot)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.records_.MergeFrom(from._impl_.records_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_mac(from._internal_mac());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom(
+          from._internal_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom(
+          from._internal_keyid());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdSnapshot::CopyFrom(const SyncdSnapshot& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdSnapshot)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdSnapshot::IsInitialized() const {
+  return true;
+}
+
+void SyncdSnapshot::InternalSwap(SyncdSnapshot* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.records_.InternalSwap(&other->_impl_.records_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mac_, lhs_arena,
+      &other->_impl_.mac_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.keyid_)
+      + sizeof(SyncdSnapshot::_impl_.keyid_)
+      - PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.version_)>(
+          reinterpret_cast<char*>(&_impl_.version_),
+          reinterpret_cast<char*>(&other->_impl_.version_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdSnapshot::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[210]);
+}
+
+// ===================================================================
+
+class SyncdValue::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdValue>()._impl_._has_bits_);
+  static void set_has_blob(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncdValue::SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdValue)
+}
+SyncdValue::SyncdValue(const SyncdValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdValue* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.blob_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.blob_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_blob()) {
+    _this->_impl_.blob_.Set(from._internal_blob(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdValue)
+}
+
+inline void SyncdValue::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.blob_){}
+  };
+  _impl_.blob_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+SyncdValue::~SyncdValue() {
+  // @@protoc_insertion_point(destructor:proto.SyncdValue)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.blob_.Destroy();
+}
+
+void SyncdValue::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.blob_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes blob = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_blob();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes blob = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_blob(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdValue)
+  return target;
+}
+
+size_t SyncdValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes blob = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_blob());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdValue::GetClassData() const { return &_class_data_; }
+
+
+void SyncdValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdValue*>(&to_msg);
+  auto& from = static_cast<const SyncdValue&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdValue)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_blob()) {
+    _this->_internal_set_blob(from._internal_blob());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdValue::CopyFrom(const SyncdValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdValue::IsInitialized() const {
+  return true;
+}
+
+void SyncdValue::InternalSwap(SyncdValue* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.blob_, lhs_arena,
+      &other->_impl_.blob_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdValue::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[211]);
+}
+
+// ===================================================================
+
+class SyncdVersion::_Internal {
+ public:
+  using HasBits = decltype(std::declval<SyncdVersion>()._impl_._has_bits_);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+SyncdVersion::SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.SyncdVersion)
+}
+SyncdVersion::SyncdVersion(const SyncdVersion& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  SyncdVersion* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.version_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.version_ = from._impl_.version_;
+  // @@protoc_insertion_point(copy_constructor:proto.SyncdVersion)
+}
+
+inline void SyncdVersion::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.version_){uint64_t{0u}}
+  };
+}
+
+SyncdVersion::~SyncdVersion() {
+  // @@protoc_insertion_point(destructor:proto.SyncdVersion)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void SyncdVersion::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void SyncdVersion::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void SyncdVersion::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.SyncdVersion)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.version_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SyncdVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_version(&has_bits);
+          _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SyncdVersion::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdVersion)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 version = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.SyncdVersion)
+  return target;
+}
+
+size_t SyncdVersion::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.SyncdVersion)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint64 version = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_version());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdVersion::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    SyncdVersion::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdVersion::GetClassData() const { return &_class_data_; }
+
+
+void SyncdVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<SyncdVersion*>(&to_msg);
+  auto& from = static_cast<const SyncdVersion&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdVersion)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_version()) {
+    _this->_internal_set_version(from._internal_version());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SyncdVersion::CopyFrom(const SyncdVersion& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdVersion)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SyncdVersion::IsInitialized() const {
+  return true;
+}
+
+void SyncdVersion::InternalSwap(SyncdVersion* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.version_, other->_impl_.version_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SyncdVersion::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[212]);
+}
+
+// ===================================================================
+
+class TemplateButton_CallButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<TemplateButton_CallButton>()._impl_._has_bits_);
+  static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_CallButton* msg);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_HighlyStructuredMessage& phonenumber(const TemplateButton_CallButton* msg);
+  static void set_has_phonenumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_HighlyStructuredMessage&
+TemplateButton_CallButton::_Internal::displaytext(const TemplateButton_CallButton* msg) {
+  return *msg->_impl_.displaytext_;
+}
+const ::proto::Message_HighlyStructuredMessage&
+TemplateButton_CallButton::_Internal::phonenumber(const TemplateButton_CallButton* msg) {
+  return *msg->_impl_.phonenumber_;
+}
+TemplateButton_CallButton::TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.CallButton)
+}
+TemplateButton_CallButton::TemplateButton_CallButton(const TemplateButton_CallButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TemplateButton_CallButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){nullptr}
+    , decltype(_impl_.phonenumber_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_);
+  }
+  if (from._internal_has_phonenumber()) {
+    _this->_impl_.phonenumber_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.phonenumber_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.CallButton)
+}
+
+inline void TemplateButton_CallButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){nullptr}
+    , decltype(_impl_.phonenumber_){nullptr}
+  };
+}
+
+TemplateButton_CallButton::~TemplateButton_CallButton() {
+  // @@protoc_insertion_point(destructor:proto.TemplateButton.CallButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TemplateButton_CallButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.displaytext_;
+  if (this != internal_default_instance()) delete _impl_.phonenumber_;
+}
+
+void TemplateButton_CallButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TemplateButton_CallButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.CallButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.displaytext_ != nullptr);
+      _impl_.displaytext_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.phonenumber_ != nullptr);
+      _impl_.phonenumber_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TemplateButton_CallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_phonenumber(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TemplateButton_CallButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.CallButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::displaytext(this),
+        _Internal::displaytext(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::phonenumber(this),
+        _Internal::phonenumber(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.TemplateButton.CallButton)
+  return target;
+}
+
+size_t TemplateButton_CallButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.CallButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.displaytext_);
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.phonenumber_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_CallButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TemplateButton_CallButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_CallButton::GetClassData() const { return &_class_data_; }
+
+
+void TemplateButton_CallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TemplateButton_CallButton*>(&to_msg);
+  auto& from = static_cast<const TemplateButton_CallButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.CallButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_displaytext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_phonenumber()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_phonenumber());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TemplateButton_CallButton::CopyFrom(const TemplateButton_CallButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.CallButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TemplateButton_CallButton::IsInitialized() const {
+  return true;
+}
+
+void TemplateButton_CallButton::InternalSwap(TemplateButton_CallButton* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.phonenumber_)
+      + sizeof(TemplateButton_CallButton::_impl_.phonenumber_)
+      - PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.displaytext_)>(
+          reinterpret_cast<char*>(&_impl_.displaytext_),
+          reinterpret_cast<char*>(&other->_impl_.displaytext_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_CallButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[213]);
+}
+
+// ===================================================================
+
+class TemplateButton_QuickReplyButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<TemplateButton_QuickReplyButton>()._impl_._has_bits_);
+  static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_QuickReplyButton* msg);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::proto::Message_HighlyStructuredMessage&
+TemplateButton_QuickReplyButton::_Internal::displaytext(const TemplateButton_QuickReplyButton* msg) {
+  return *msg->_impl_.displaytext_;
+}
+TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.QuickReplyButton)
+}
+TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TemplateButton_QuickReplyButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.displaytext_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.QuickReplyButton)
+}
+
+inline void TemplateButton_QuickReplyButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.displaytext_){nullptr}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+TemplateButton_QuickReplyButton::~TemplateButton_QuickReplyButton() {
+  // @@protoc_insertion_point(destructor:proto.TemplateButton.QuickReplyButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TemplateButton_QuickReplyButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.displaytext_;
+}
+
+void TemplateButton_QuickReplyButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TemplateButton_QuickReplyButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.QuickReplyButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.displaytext_ != nullptr);
+      _impl_.displaytext_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TemplateButton_QuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.TemplateButton.QuickReplyButton.id");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TemplateButton_QuickReplyButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.QuickReplyButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::displaytext(this),
+        _Internal::displaytext(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string id = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.TemplateButton.QuickReplyButton.id");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.TemplateButton.QuickReplyButton)
+  return target;
+}
+
+size_t TemplateButton_QuickReplyButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.QuickReplyButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string id = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.displaytext_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_QuickReplyButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TemplateButton_QuickReplyButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_QuickReplyButton::GetClassData() const { return &_class_data_; }
+
+
+void TemplateButton_QuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TemplateButton_QuickReplyButton*>(&to_msg);
+  auto& from = static_cast<const TemplateButton_QuickReplyButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.QuickReplyButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_displaytext());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TemplateButton_QuickReplyButton::CopyFrom(const TemplateButton_QuickReplyButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.QuickReplyButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TemplateButton_QuickReplyButton::IsInitialized() const {
+  return true;
+}
+
+void TemplateButton_QuickReplyButton::InternalSwap(TemplateButton_QuickReplyButton* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  swap(_impl_.displaytext_, other->_impl_.displaytext_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_QuickReplyButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[214]);
+}
+
+// ===================================================================
+
+class TemplateButton_URLButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<TemplateButton_URLButton>()._impl_._has_bits_);
+  static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_URLButton* msg);
+  static void set_has_displaytext(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::Message_HighlyStructuredMessage& url(const TemplateButton_URLButton* msg);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::proto::Message_HighlyStructuredMessage&
+TemplateButton_URLButton::_Internal::displaytext(const TemplateButton_URLButton* msg) {
+  return *msg->_impl_.displaytext_;
+}
+const ::proto::Message_HighlyStructuredMessage&
+TemplateButton_URLButton::_Internal::url(const TemplateButton_URLButton* msg) {
+  return *msg->_impl_.url_;
+}
+TemplateButton_URLButton::TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.URLButton)
+}
+TemplateButton_URLButton::TemplateButton_URLButton(const TemplateButton_URLButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TemplateButton_URLButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){nullptr}
+    , decltype(_impl_.url_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_displaytext()) {
+    _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_);
+  }
+  if (from._internal_has_url()) {
+    _this->_impl_.url_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.url_);
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.URLButton)
+}
+
+inline void TemplateButton_URLButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.displaytext_){nullptr}
+    , decltype(_impl_.url_){nullptr}
+  };
+}
+
+TemplateButton_URLButton::~TemplateButton_URLButton() {
+  // @@protoc_insertion_point(destructor:proto.TemplateButton.URLButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TemplateButton_URLButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.displaytext_;
+  if (this != internal_default_instance()) delete _impl_.url_;
+}
+
+void TemplateButton_URLButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TemplateButton_URLButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.URLButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.displaytext_ != nullptr);
+      _impl_.displaytext_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.url_ != nullptr);
+      _impl_.url_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TemplateButton_URLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.HighlyStructuredMessage url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_url(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TemplateButton_URLButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.URLButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::displaytext(this),
+        _Internal::displaytext(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.HighlyStructuredMessage url = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::url(this),
+        _Internal::url(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.TemplateButton.URLButton)
+  return target;
+}
+
+size_t TemplateButton_URLButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.URLButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.displaytext_);
+    }
+
+    // optional .proto.Message.HighlyStructuredMessage url = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.url_);
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_URLButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TemplateButton_URLButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_URLButton::GetClassData() const { return &_class_data_; }
+
+
+void TemplateButton_URLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TemplateButton_URLButton*>(&to_msg);
+  auto& from = static_cast<const TemplateButton_URLButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.URLButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_displaytext());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_url()->::proto::Message_HighlyStructuredMessage::MergeFrom(
+          from._internal_url());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TemplateButton_URLButton::CopyFrom(const TemplateButton_URLButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.URLButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TemplateButton_URLButton::IsInitialized() const {
+  return true;
+}
+
+void TemplateButton_URLButton::InternalSwap(TemplateButton_URLButton* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.url_)
+      + sizeof(TemplateButton_URLButton::_impl_.url_)
+      - PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.displaytext_)>(
+          reinterpret_cast<char*>(&_impl_.displaytext_),
+          reinterpret_cast<char*>(&other->_impl_.displaytext_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_URLButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[215]);
+}
+
+// ===================================================================
+
+class TemplateButton::_Internal {
+ public:
+  using HasBits = decltype(std::declval<TemplateButton>()._impl_._has_bits_);
+  static void set_has_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::proto::TemplateButton_QuickReplyButton& quickreplybutton(const TemplateButton* msg);
+  static const ::proto::TemplateButton_URLButton& urlbutton(const TemplateButton* msg);
+  static const ::proto::TemplateButton_CallButton& callbutton(const TemplateButton* msg);
+};
+
+const ::proto::TemplateButton_QuickReplyButton&
+TemplateButton::_Internal::quickreplybutton(const TemplateButton* msg) {
+  return *msg->_impl_.button_.quickreplybutton_;
+}
+const ::proto::TemplateButton_URLButton&
+TemplateButton::_Internal::urlbutton(const TemplateButton* msg) {
+  return *msg->_impl_.button_.urlbutton_;
+}
+const ::proto::TemplateButton_CallButton&
+TemplateButton::_Internal::callbutton(const TemplateButton* msg) {
+  return *msg->_impl_.button_.callbutton_;
+}
+void TemplateButton::set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_button();
+  if (quickreplybutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton);
+    if (message_arena != submessage_arena) {
+      quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quickreplybutton, submessage_arena);
+    }
+    set_has_quickreplybutton();
+    _impl_.button_.quickreplybutton_ = quickreplybutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.quickReplyButton)
+}
+void TemplateButton::set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_button();
+  if (urlbutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton);
+    if (message_arena != submessage_arena) {
+      urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, urlbutton, submessage_arena);
+    }
+    set_has_urlbutton();
+    _impl_.button_.urlbutton_ = urlbutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.urlButton)
+}
+void TemplateButton::set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_button();
+  if (callbutton) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton);
+    if (message_arena != submessage_arena) {
+      callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, callbutton, submessage_arena);
+    }
+    set_has_callbutton();
+    _impl_.button_.callbutton_ = callbutton;
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.callButton)
+}
+TemplateButton::TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.TemplateButton)
+}
+TemplateButton::TemplateButton(const TemplateButton& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TemplateButton* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){}
+    , decltype(_impl_.button_){}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.index_ = from._impl_.index_;
+  clear_has_button();
+  switch (from.button_case()) {
+    case kQuickReplyButton: {
+      _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom(
+          from._internal_quickreplybutton());
+      break;
+    }
+    case kUrlButton: {
+      _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom(
+          from._internal_urlbutton());
+      break;
+    }
+    case kCallButton: {
+      _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom(
+          from._internal_callbutton());
+      break;
+    }
+    case BUTTON_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.TemplateButton)
+}
+
+inline void TemplateButton::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.index_){0u}
+    , decltype(_impl_.button_){}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_button();
+}
+
+TemplateButton::~TemplateButton() {
+  // @@protoc_insertion_point(destructor:proto.TemplateButton)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TemplateButton::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_button()) {
+    clear_button();
+  }
+}
+
+void TemplateButton::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TemplateButton::clear_button() {
+// @@protoc_insertion_point(one_of_clear_start:proto.TemplateButton)
+  switch (button_case()) {
+    case kQuickReplyButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.button_.quickreplybutton_;
+      }
+      break;
+    }
+    case kUrlButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.button_.urlbutton_;
+      }
+      break;
+    }
+    case kCallButton: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.button_.callbutton_;
+      }
+      break;
+    }
+    case BUTTON_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = BUTTON_NOT_SET;
+}
+
+
+void TemplateButton::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.TemplateButton)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.index_ = 0u;
+  clear_button();
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.TemplateButton.URLButton urlButton = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .proto.TemplateButton.CallButton callButton = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 index = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_index(&has_bits);
+          _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TemplateButton::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (button_case()) {
+    case kQuickReplyButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, _Internal::quickreplybutton(this),
+          _Internal::quickreplybutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kUrlButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, _Internal::urlbutton(this),
+          _Internal::urlbutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    case kCallButton: {
+      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, _Internal::callbutton(this),
+          _Internal::callbutton(this).GetCachedSize(), target, stream);
+      break;
+    }
+    default: ;
+  }
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 index = 4;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.TemplateButton)
+  return target;
+}
+
+size_t TemplateButton::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint32 index = 4;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+  }
+
+  switch (button_case()) {
+    // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
+    case kQuickReplyButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.button_.quickreplybutton_);
+      break;
+    }
+    // .proto.TemplateButton.URLButton urlButton = 2;
+    case kUrlButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.button_.urlbutton_);
+      break;
+    }
+    // .proto.TemplateButton.CallButton callButton = 3;
+    case kCallButton: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.button_.callbutton_);
+      break;
+    }
+    case BUTTON_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TemplateButton::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton::GetClassData() const { return &_class_data_; }
+
+
+void TemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TemplateButton*>(&to_msg);
+  auto& from = static_cast<const TemplateButton&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_index()) {
+    _this->_internal_set_index(from._internal_index());
+  }
+  switch (from.button_case()) {
+    case kQuickReplyButton: {
+      _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom(
+          from._internal_quickreplybutton());
+      break;
+    }
+    case kUrlButton: {
+      _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom(
+          from._internal_urlbutton());
+      break;
+    }
+    case kCallButton: {
+      _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom(
+          from._internal_callbutton());
+      break;
+    }
+    case BUTTON_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TemplateButton::CopyFrom(const TemplateButton& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TemplateButton::IsInitialized() const {
+  return true;
+}
+
+void TemplateButton::InternalSwap(TemplateButton* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.index_, other->_impl_.index_);
+  swap(_impl_.button_, other->_impl_.button_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[216]);
+}
+
+// ===================================================================
+
+class UserReceipt::_Internal {
+ public:
+  using HasBits = decltype(std::declval<UserReceipt>()._impl_._has_bits_);
+  static void set_has_userjid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_receipttimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_readtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_playedtimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+UserReceipt::UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.UserReceipt)
+}
+UserReceipt::UserReceipt(const UserReceipt& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  UserReceipt* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pendingdevicejid_){from._impl_.pendingdevicejid_}
+    , decltype(_impl_.delivereddevicejid_){from._impl_.delivereddevicejid_}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.receipttimestamp_){}
+    , decltype(_impl_.readtimestamp_){}
+    , decltype(_impl_.playedtimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_userjid()) {
+    _this->_impl_.userjid_.Set(from._internal_userjid(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.receipttimestamp_, &from._impl_.receipttimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.playedtimestamp_) -
+    reinterpret_cast<char*>(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.UserReceipt)
+}
+
+inline void UserReceipt::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.pendingdevicejid_){arena}
+    , decltype(_impl_.delivereddevicejid_){arena}
+    , decltype(_impl_.userjid_){}
+    , decltype(_impl_.receipttimestamp_){int64_t{0}}
+    , decltype(_impl_.readtimestamp_){int64_t{0}}
+    , decltype(_impl_.playedtimestamp_){int64_t{0}}
+  };
+  _impl_.userjid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+UserReceipt::~UserReceipt() {
+  // @@protoc_insertion_point(destructor:proto.UserReceipt)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void UserReceipt::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.pendingdevicejid_.~RepeatedPtrField();
+  _impl_.delivereddevicejid_.~RepeatedPtrField();
+  _impl_.userjid_.Destroy();
+}
+
+void UserReceipt::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void UserReceipt::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.UserReceipt)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.pendingdevicejid_.Clear();
+  _impl_.delivereddevicejid_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.userjid_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000000eu) {
+    ::memset(&_impl_.receipttimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.playedtimestamp_) -
+        reinterpret_cast<char*>(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* UserReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string userJid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_userjid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.UserReceipt.userJid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 receiptTimestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_receipttimestamp(&has_bits);
+          _impl_.receipttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 readTimestamp = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_readtimestamp(&has_bits);
+          _impl_.readtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 playedTimestamp = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_playedtimestamp(&has_bits);
+          _impl_.playedtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string pendingDeviceJid = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_pendingdevicejid();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.UserReceipt.pendingDeviceJid");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string deliveredDeviceJid = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_delivereddevicejid();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.UserReceipt.deliveredDeviceJid");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* UserReceipt::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.UserReceipt)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string userJid = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_userjid().data(), static_cast<int>(this->_internal_userjid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.UserReceipt.userJid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_userjid(), target);
+  }
+
+  // optional int64 receiptTimestamp = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_receipttimestamp(), target);
+  }
+
+  // optional int64 readTimestamp = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_readtimestamp(), target);
+  }
+
+  // optional int64 playedTimestamp = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_playedtimestamp(), target);
+  }
+
+  // repeated string pendingDeviceJid = 5;
+  for (int i = 0, n = this->_internal_pendingdevicejid_size(); i < n; i++) {
+    const auto& s = this->_internal_pendingdevicejid(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.UserReceipt.pendingDeviceJid");
+    target = stream->WriteString(5, s, target);
+  }
+
+  // repeated string deliveredDeviceJid = 6;
+  for (int i = 0, n = this->_internal_delivereddevicejid_size(); i < n; i++) {
+    const auto& s = this->_internal_delivereddevicejid(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.UserReceipt.deliveredDeviceJid");
+    target = stream->WriteString(6, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.UserReceipt)
+  return target;
+}
+
+size_t UserReceipt::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.UserReceipt)
+  size_t total_size = 0;
+
+  // required string userJid = 1;
+  if (_internal_has_userjid()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userjid());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string pendingDeviceJid = 5;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.pendingdevicejid_.size());
+  for (int i = 0, n = _impl_.pendingdevicejid_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.pendingdevicejid_.Get(i));
+  }
+
+  // repeated string deliveredDeviceJid = 6;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.delivereddevicejid_.size());
+  for (int i = 0, n = _impl_.delivereddevicejid_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.delivereddevicejid_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000eu) {
+    // optional int64 receiptTimestamp = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_receipttimestamp());
+    }
+
+    // optional int64 readTimestamp = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_readtimestamp());
+    }
+
+    // optional int64 playedTimestamp = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_playedtimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserReceipt::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    UserReceipt::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserReceipt::GetClassData() const { return &_class_data_; }
+
+
+void UserReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<UserReceipt*>(&to_msg);
+  auto& from = static_cast<const UserReceipt&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.UserReceipt)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.pendingdevicejid_.MergeFrom(from._impl_.pendingdevicejid_);
+  _this->_impl_.delivereddevicejid_.MergeFrom(from._impl_.delivereddevicejid_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_userjid(from._internal_userjid());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.receipttimestamp_ = from._impl_.receipttimestamp_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.readtimestamp_ = from._impl_.readtimestamp_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.playedtimestamp_ = from._impl_.playedtimestamp_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void UserReceipt::CopyFrom(const UserReceipt& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.UserReceipt)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UserReceipt::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void UserReceipt::InternalSwap(UserReceipt* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.pendingdevicejid_.InternalSwap(&other->_impl_.pendingdevicejid_);
+  _impl_.delivereddevicejid_.InternalSwap(&other->_impl_.delivereddevicejid_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.userjid_, lhs_arena,
+      &other->_impl_.userjid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.playedtimestamp_)
+      + sizeof(UserReceipt::_impl_.playedtimestamp_)
+      - PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.receipttimestamp_)>(
+          reinterpret_cast<char*>(&_impl_.receipttimestamp_),
+          reinterpret_cast<char*>(&other->_impl_.receipttimestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata UserReceipt::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[217]);
+}
+
+// ===================================================================
+
+class VerifiedNameCertificate_Details::_Internal {
+ public:
+  using HasBits = decltype(std::declval<VerifiedNameCertificate_Details>()._impl_._has_bits_);
+  static void set_has_serial(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_issuer(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_verifiedname(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_issuetime(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate.Details)
+}
+VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  VerifiedNameCertificate_Details* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localizednames_){from._impl_.localizednames_}
+    , decltype(_impl_.issuer_){}
+    , decltype(_impl_.verifiedname_){}
+    , decltype(_impl_.serial_){}
+    , decltype(_impl_.issuetime_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.issuer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_issuer()) {
+    _this->_impl_.issuer_.Set(from._internal_issuer(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.verifiedname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_verifiedname()) {
+    _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), 
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.serial_, &from._impl_.serial_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.issuetime_) -
+    reinterpret_cast<char*>(&_impl_.serial_)) + sizeof(_impl_.issuetime_));
+  // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate.Details)
+}
+
+inline void VerifiedNameCertificate_Details::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.localizednames_){arena}
+    , decltype(_impl_.issuer_){}
+    , decltype(_impl_.verifiedname_){}
+    , decltype(_impl_.serial_){uint64_t{0u}}
+    , decltype(_impl_.issuetime_){uint64_t{0u}}
+  };
+  _impl_.issuer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.verifiedname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+VerifiedNameCertificate_Details::~VerifiedNameCertificate_Details() {
+  // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate.Details)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void VerifiedNameCertificate_Details::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.localizednames_.~RepeatedPtrField();
+  _impl_.issuer_.Destroy();
+  _impl_.verifiedname_.Destroy();
+}
+
+void VerifiedNameCertificate_Details::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void VerifiedNameCertificate_Details::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.localizednames_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.issuer_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.verifiedname_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.serial_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.issuetime_) -
+        reinterpret_cast<char*>(&_impl_.serial_)) + sizeof(_impl_.issuetime_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* VerifiedNameCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 serial = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_serial(&has_bits);
+          _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string issuer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_issuer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.issuer");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string verifiedName = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_verifiedname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.verifiedName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.LocalizedName localizedNames = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_localizednames(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 issueTime = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_issuetime(&has_bits);
+          _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* VerifiedNameCertificate_Details::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate.Details)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 serial = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_serial(), target);
+  }
+
+  // optional string issuer = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_issuer().data(), static_cast<int>(this->_internal_issuer().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.VerifiedNameCertificate.Details.issuer");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_issuer(), target);
+  }
+
+  // optional string verifiedName = 4;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_verifiedname().data(), static_cast<int>(this->_internal_verifiedname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.VerifiedNameCertificate.Details.verifiedName");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_verifiedname(), target);
+  }
+
+  // repeated .proto.LocalizedName localizedNames = 8;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_localizednames_size()); i < n; i++) {
+    const auto& repfield = this->_internal_localizednames(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional uint64 issueTime = 10;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(10, this->_internal_issuetime(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.VerifiedNameCertificate.Details)
+  return target;
+}
+
+size_t VerifiedNameCertificate_Details::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate.Details)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.LocalizedName localizedNames = 8;
+  total_size += 1UL * this->_internal_localizednames_size();
+  for (const auto& msg : this->_impl_.localizednames_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string issuer = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_issuer());
+    }
+
+    // optional string verifiedName = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_verifiedname());
+    }
+
+    // optional uint64 serial = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_serial());
+    }
+
+    // optional uint64 issueTime = 10;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate_Details::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    VerifiedNameCertificate_Details::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate_Details::GetClassData() const { return &_class_data_; }
+
+
+void VerifiedNameCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<VerifiedNameCertificate_Details*>(&to_msg);
+  auto& from = static_cast<const VerifiedNameCertificate_Details&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate.Details)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.localizednames_.MergeFrom(from._impl_.localizednames_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_issuer(from._internal_issuer());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_verifiedname(from._internal_verifiedname());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.serial_ = from._impl_.serial_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.issuetime_ = from._impl_.issuetime_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void VerifiedNameCertificate_Details::CopyFrom(const VerifiedNameCertificate_Details& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate.Details)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VerifiedNameCertificate_Details::IsInitialized() const {
+  return true;
+}
+
+void VerifiedNameCertificate_Details::InternalSwap(VerifiedNameCertificate_Details* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.localizednames_.InternalSwap(&other->_impl_.localizednames_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.issuer_, lhs_arena,
+      &other->_impl_.issuer_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.verifiedname_, lhs_arena,
+      &other->_impl_.verifiedname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.issuetime_)
+      + sizeof(VerifiedNameCertificate_Details::_impl_.issuetime_)
+      - PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.serial_)>(
+          reinterpret_cast<char*>(&_impl_.serial_),
+          reinterpret_cast<char*>(&other->_impl_.serial_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate_Details::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[218]);
+}
+
+// ===================================================================
+
+class VerifiedNameCertificate::_Internal {
+ public:
+  using HasBits = decltype(std::declval<VerifiedNameCertificate>()._impl_._has_bits_);
+  static void set_has_details(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_serversignature(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+VerifiedNameCertificate::VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate)
+}
+VerifiedNameCertificate::VerifiedNameCertificate(const VerifiedNameCertificate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  VerifiedNameCertificate* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}
+    , decltype(_impl_.serversignature_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_details()) {
+    _this->_impl_.details_.Set(from._internal_details(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_.Set(from._internal_signature(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.serversignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.serversignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_serversignature()) {
+    _this->_impl_.serversignature_.Set(from._internal_serversignature(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate)
+}
+
+inline void VerifiedNameCertificate::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.details_){}
+    , decltype(_impl_.signature_){}
+    , decltype(_impl_.serversignature_){}
+  };
+  _impl_.details_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.details_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.serversignature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.serversignature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+VerifiedNameCertificate::~VerifiedNameCertificate() {
+  // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void VerifiedNameCertificate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.details_.Destroy();
+  _impl_.signature_.Destroy();
+  _impl_.serversignature_.Destroy();
+}
+
+void VerifiedNameCertificate::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void VerifiedNameCertificate::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.details_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.signature_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.serversignature_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* VerifiedNameCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes details = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_details();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes signature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_signature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes serverSignature = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_serversignature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* VerifiedNameCertificate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes details = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_details(), target);
+  }
+
+  // optional bytes signature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_signature(), target);
+  }
+
+  // optional bytes serverSignature = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_serversignature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.VerifiedNameCertificate)
+  return target;
+}
+
+size_t VerifiedNameCertificate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes details = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_details());
+    }
+
+    // optional bytes signature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_signature());
+    }
+
+    // optional bytes serverSignature = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_serversignature());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    VerifiedNameCertificate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate::GetClassData() const { return &_class_data_; }
+
+
+void VerifiedNameCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<VerifiedNameCertificate*>(&to_msg);
+  auto& from = static_cast<const VerifiedNameCertificate&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_details(from._internal_details());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_signature(from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_serversignature(from._internal_serversignature());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void VerifiedNameCertificate::CopyFrom(const VerifiedNameCertificate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VerifiedNameCertificate::IsInitialized() const {
+  return true;
+}
+
+void VerifiedNameCertificate::InternalSwap(VerifiedNameCertificate* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.details_, lhs_arena,
+      &other->_impl_.details_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.signature_, lhs_arena,
+      &other->_impl_.signature_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.serversignature_, lhs_arena,
+      &other->_impl_.serversignature_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[219]);
+}
+
+// ===================================================================
+
+class WallpaperSettings::_Internal {
+ public:
+  using HasBits = decltype(std::declval<WallpaperSettings>()._impl_._has_bits_);
+  static void set_has_filename(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_opacity(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+WallpaperSettings::WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.WallpaperSettings)
+}
+WallpaperSettings::WallpaperSettings(const WallpaperSettings& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  WallpaperSettings* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filename_){}
+    , decltype(_impl_.opacity_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_filename()) {
+    _this->_impl_.filename_.Set(from._internal_filename(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.opacity_ = from._impl_.opacity_;
+  // @@protoc_insertion_point(copy_constructor:proto.WallpaperSettings)
+}
+
+inline void WallpaperSettings::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.filename_){}
+    , decltype(_impl_.opacity_){0u}
+  };
+  _impl_.filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+WallpaperSettings::~WallpaperSettings() {
+  // @@protoc_insertion_point(destructor:proto.WallpaperSettings)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void WallpaperSettings::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.filename_.Destroy();
+}
+
+void WallpaperSettings::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void WallpaperSettings::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.WallpaperSettings)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.filename_.ClearNonDefaultToEmpty();
+  }
+  _impl_.opacity_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WallpaperSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string filename = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_filename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WallpaperSettings.filename");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 opacity = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_opacity(&has_bits);
+          _impl_.opacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* WallpaperSettings::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.WallpaperSettings)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string filename = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_filename().data(), static_cast<int>(this->_internal_filename().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WallpaperSettings.filename");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_filename(), target);
+  }
+
+  // optional uint32 opacity = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_opacity(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.WallpaperSettings)
+  return target;
+}
+
+size_t WallpaperSettings::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.WallpaperSettings)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string filename = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_filename());
+    }
+
+    // optional uint32 opacity = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_opacity());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WallpaperSettings::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    WallpaperSettings::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WallpaperSettings::GetClassData() const { return &_class_data_; }
+
+
+void WallpaperSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<WallpaperSettings*>(&to_msg);
+  auto& from = static_cast<const WallpaperSettings&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.WallpaperSettings)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_filename(from._internal_filename());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.opacity_ = from._impl_.opacity_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void WallpaperSettings::CopyFrom(const WallpaperSettings& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.WallpaperSettings)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WallpaperSettings::IsInitialized() const {
+  return true;
+}
+
+void WallpaperSettings::InternalSwap(WallpaperSettings* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.filename_, lhs_arena,
+      &other->_impl_.filename_, rhs_arena
+  );
+  swap(_impl_.opacity_, other->_impl_.opacity_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WallpaperSettings::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[220]);
+}
+
+// ===================================================================
+
+class WebFeatures::_Internal {
+ public:
+  using HasBits = decltype(std::declval<WebFeatures>()._impl_._has_bits_);
+  static void set_has_labelsdisplay(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_voipindividualoutgoing(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_groupsv3(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_groupsv3create(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_changenumberv2(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_querystatusv3thumbnail(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_livelocations(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_queryvname(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_voipindividualincoming(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_quickrepliesquery(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_payments(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_stickerpackquery(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_livelocationsfinal(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_labelsedit(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_mediaupload(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_mediauploadrichquickreplies(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_vnamev2(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_videoplaybackurl(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_statusranking(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_voipindividualvideo(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_thirdpartystickers(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_frequentlyforwardedsetting(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_groupsv4joinpermission(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static void set_has_recentstickers(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static void set_has_catalog(HasBits* has_bits) {
+    (*has_bits)[0] |= 16777216u;
+  }
+  static void set_has_starredstickers(HasBits* has_bits) {
+    (*has_bits)[0] |= 33554432u;
+  }
+  static void set_has_voipgroupcall(HasBits* has_bits) {
+    (*has_bits)[0] |= 67108864u;
+  }
+  static void set_has_templatemessage(HasBits* has_bits) {
+    (*has_bits)[0] |= 134217728u;
+  }
+  static void set_has_templatemessageinteractivity(HasBits* has_bits) {
+    (*has_bits)[0] |= 268435456u;
+  }
+  static void set_has_ephemeralmessages(HasBits* has_bits) {
+    (*has_bits)[0] |= 536870912u;
+  }
+  static void set_has_e2enotificationsync(HasBits* has_bits) {
+    (*has_bits)[0] |= 1073741824u;
+  }
+  static void set_has_recentstickersv2(HasBits* has_bits) {
+    (*has_bits)[0] |= 2147483648u;
+  }
+  static void set_has_recentstickersv3(HasBits* has_bits) {
+    (*has_bits)[1] |= 1u;
+  }
+  static void set_has_usernotice(HasBits* has_bits) {
+    (*has_bits)[1] |= 2u;
+  }
+  static void set_has_support(HasBits* has_bits) {
+    (*has_bits)[1] |= 4u;
+  }
+  static void set_has_groupuiicleanup(HasBits* has_bits) {
+    (*has_bits)[1] |= 8u;
+  }
+  static void set_has_groupdogfoodinginternalonly(HasBits* has_bits) {
+    (*has_bits)[1] |= 16u;
+  }
+  static void set_has_settingssync(HasBits* has_bits) {
+    (*has_bits)[1] |= 32u;
+  }
+  static void set_has_archivev2(HasBits* has_bits) {
+    (*has_bits)[1] |= 64u;
+  }
+  static void set_has_ephemeralallowgroupmembers(HasBits* has_bits) {
+    (*has_bits)[1] |= 128u;
+  }
+  static void set_has_ephemeral24hduration(HasBits* has_bits) {
+    (*has_bits)[1] |= 256u;
+  }
+  static void set_has_mdforceupgrade(HasBits* has_bits) {
+    (*has_bits)[1] |= 512u;
+  }
+  static void set_has_disappearingmode(HasBits* has_bits) {
+    (*has_bits)[1] |= 1024u;
+  }
+  static void set_has_externalmdoptinavailable(HasBits* has_bits) {
+    (*has_bits)[1] |= 2048u;
+  }
+  static void set_has_nodeletemessagetimelimit(HasBits* has_bits) {
+    (*has_bits)[1] |= 4096u;
+  }
+};
+
+WebFeatures::WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.WebFeatures)
+}
+WebFeatures::WebFeatures(const WebFeatures& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  WebFeatures* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.labelsdisplay_){}
+    , decltype(_impl_.voipindividualoutgoing_){}
+    , decltype(_impl_.groupsv3_){}
+    , decltype(_impl_.groupsv3create_){}
+    , decltype(_impl_.changenumberv2_){}
+    , decltype(_impl_.querystatusv3thumbnail_){}
+    , decltype(_impl_.livelocations_){}
+    , decltype(_impl_.queryvname_){}
+    , decltype(_impl_.voipindividualincoming_){}
+    , decltype(_impl_.quickrepliesquery_){}
+    , decltype(_impl_.payments_){}
+    , decltype(_impl_.stickerpackquery_){}
+    , decltype(_impl_.livelocationsfinal_){}
+    , decltype(_impl_.labelsedit_){}
+    , decltype(_impl_.mediaupload_){}
+    , decltype(_impl_.mediauploadrichquickreplies_){}
+    , decltype(_impl_.vnamev2_){}
+    , decltype(_impl_.videoplaybackurl_){}
+    , decltype(_impl_.statusranking_){}
+    , decltype(_impl_.voipindividualvideo_){}
+    , decltype(_impl_.thirdpartystickers_){}
+    , decltype(_impl_.frequentlyforwardedsetting_){}
+    , decltype(_impl_.groupsv4joinpermission_){}
+    , decltype(_impl_.recentstickers_){}
+    , decltype(_impl_.catalog_){}
+    , decltype(_impl_.starredstickers_){}
+    , decltype(_impl_.voipgroupcall_){}
+    , decltype(_impl_.templatemessage_){}
+    , decltype(_impl_.templatemessageinteractivity_){}
+    , decltype(_impl_.ephemeralmessages_){}
+    , decltype(_impl_.e2enotificationsync_){}
+    , decltype(_impl_.recentstickersv2_){}
+    , decltype(_impl_.recentstickersv3_){}
+    , decltype(_impl_.usernotice_){}
+    , decltype(_impl_.support_){}
+    , decltype(_impl_.groupuiicleanup_){}
+    , decltype(_impl_.groupdogfoodinginternalonly_){}
+    , decltype(_impl_.settingssync_){}
+    , decltype(_impl_.archivev2_){}
+    , decltype(_impl_.ephemeralallowgroupmembers_){}
+    , decltype(_impl_.ephemeral24hduration_){}
+    , decltype(_impl_.mdforceupgrade_){}
+    , decltype(_impl_.disappearingmode_){}
+    , decltype(_impl_.externalmdoptinavailable_){}
+    , decltype(_impl_.nodeletemessagetimelimit_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.labelsdisplay_, &from._impl_.labelsdisplay_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nodeletemessagetimelimit_) -
+    reinterpret_cast<char*>(&_impl_.labelsdisplay_)) + sizeof(_impl_.nodeletemessagetimelimit_));
+  // @@protoc_insertion_point(copy_constructor:proto.WebFeatures)
+}
+
+inline void WebFeatures::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.labelsdisplay_){0}
+    , decltype(_impl_.voipindividualoutgoing_){0}
+    , decltype(_impl_.groupsv3_){0}
+    , decltype(_impl_.groupsv3create_){0}
+    , decltype(_impl_.changenumberv2_){0}
+    , decltype(_impl_.querystatusv3thumbnail_){0}
+    , decltype(_impl_.livelocations_){0}
+    , decltype(_impl_.queryvname_){0}
+    , decltype(_impl_.voipindividualincoming_){0}
+    , decltype(_impl_.quickrepliesquery_){0}
+    , decltype(_impl_.payments_){0}
+    , decltype(_impl_.stickerpackquery_){0}
+    , decltype(_impl_.livelocationsfinal_){0}
+    , decltype(_impl_.labelsedit_){0}
+    , decltype(_impl_.mediaupload_){0}
+    , decltype(_impl_.mediauploadrichquickreplies_){0}
+    , decltype(_impl_.vnamev2_){0}
+    , decltype(_impl_.videoplaybackurl_){0}
+    , decltype(_impl_.statusranking_){0}
+    , decltype(_impl_.voipindividualvideo_){0}
+    , decltype(_impl_.thirdpartystickers_){0}
+    , decltype(_impl_.frequentlyforwardedsetting_){0}
+    , decltype(_impl_.groupsv4joinpermission_){0}
+    , decltype(_impl_.recentstickers_){0}
+    , decltype(_impl_.catalog_){0}
+    , decltype(_impl_.starredstickers_){0}
+    , decltype(_impl_.voipgroupcall_){0}
+    , decltype(_impl_.templatemessage_){0}
+    , decltype(_impl_.templatemessageinteractivity_){0}
+    , decltype(_impl_.ephemeralmessages_){0}
+    , decltype(_impl_.e2enotificationsync_){0}
+    , decltype(_impl_.recentstickersv2_){0}
+    , decltype(_impl_.recentstickersv3_){0}
+    , decltype(_impl_.usernotice_){0}
+    , decltype(_impl_.support_){0}
+    , decltype(_impl_.groupuiicleanup_){0}
+    , decltype(_impl_.groupdogfoodinginternalonly_){0}
+    , decltype(_impl_.settingssync_){0}
+    , decltype(_impl_.archivev2_){0}
+    , decltype(_impl_.ephemeralallowgroupmembers_){0}
+    , decltype(_impl_.ephemeral24hduration_){0}
+    , decltype(_impl_.mdforceupgrade_){0}
+    , decltype(_impl_.disappearingmode_){0}
+    , decltype(_impl_.externalmdoptinavailable_){0}
+    , decltype(_impl_.nodeletemessagetimelimit_){0}
+  };
+}
+
+WebFeatures::~WebFeatures() {
+  // @@protoc_insertion_point(destructor:proto.WebFeatures)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void WebFeatures::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void WebFeatures::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void WebFeatures::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.WebFeatures)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    ::memset(&_impl_.labelsdisplay_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.queryvname_) -
+        reinterpret_cast<char*>(&_impl_.labelsdisplay_)) + sizeof(_impl_.queryvname_));
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    ::memset(&_impl_.voipindividualincoming_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.mediauploadrichquickreplies_) -
+        reinterpret_cast<char*>(&_impl_.voipindividualincoming_)) + sizeof(_impl_.mediauploadrichquickreplies_));
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    ::memset(&_impl_.vnamev2_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.recentstickers_) -
+        reinterpret_cast<char*>(&_impl_.vnamev2_)) + sizeof(_impl_.recentstickers_));
+  }
+  if (cached_has_bits & 0xff000000u) {
+    ::memset(&_impl_.catalog_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.recentstickersv2_) -
+        reinterpret_cast<char*>(&_impl_.catalog_)) + sizeof(_impl_.recentstickersv2_));
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    ::memset(&_impl_.recentstickersv3_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.ephemeralallowgroupmembers_) -
+        reinterpret_cast<char*>(&_impl_.recentstickersv3_)) + sizeof(_impl_.ephemeralallowgroupmembers_));
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    ::memset(&_impl_.ephemeral24hduration_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.nodeletemessagetimelimit_) -
+        reinterpret_cast<char*>(&_impl_.ephemeral24hduration_)) + sizeof(_impl_.nodeletemessagetimelimit_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WebFeatures::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .proto.WebFeatures.Flag labelsDisplay = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_labelsdisplay(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_voipindividualoutgoing(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag groupsV3 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_groupsv3(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag groupsV3Create = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_groupsv3create(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag changeNumberV2 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_changenumberv2(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_querystatusv3thumbnail(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag liveLocations = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_livelocations(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag queryVname = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_queryvname(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_voipindividualincoming(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_quickrepliesquery(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag payments = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_payments(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag stickerPackQuery = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_stickerpackquery(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_livelocationsfinal(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag labelsEdit = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_labelsedit(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag mediaUpload = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_mediaupload(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_mediauploadrichquickreplies(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(18, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag vnameV2 = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_vnamev2(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_videoplaybackurl(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag statusRanking = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_statusranking(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(21, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_voipindividualvideo(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(22, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_thirdpartystickers(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(23, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_frequentlyforwardedsetting(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_groupsv4joinpermission(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(25, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag recentStickers = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_recentstickers(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag catalog = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_catalog(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag starredStickers = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_starredstickers(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(28, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag voipGroupCall = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_voipgroupcall(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag templateMessage = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_templatemessage(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_templatemessageinteractivity(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(31, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag ephemeralMessages = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_ephemeralmessages(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(32, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_e2enotificationsync(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(33, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag recentStickersV2 = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_recentstickersv2(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(34, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag recentStickersV3 = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_recentstickersv3(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag userNotice = 37;
+      case 37:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_usernotice(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(37, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag support = 39;
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_support(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(39, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
+      case 40:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_groupuiicleanup(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(40, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
+      case 41:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_groupdogfoodinginternalonly(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(41, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag settingsSync = 42;
+      case 42:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_settingssync(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(42, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag archiveV2 = 43;
+      case 43:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_archivev2(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(43, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
+      case 44:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_ephemeralallowgroupmembers(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(44, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
+      case 45:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_ephemeral24hduration(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(45, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
+      case 46:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_mdforceupgrade(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(46, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag disappearingMode = 47;
+      case 47:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_disappearingmode(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(47, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
+      case 48:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_externalmdoptinavailable(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(48, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
+      case 49:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) {
+            _internal_set_nodeletemessagetimelimit(static_cast<::proto::WebFeatures_Flag>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(49, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* WebFeatures::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.WebFeatures)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .proto.WebFeatures.Flag labelsDisplay = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_labelsdisplay(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_voipindividualoutgoing(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag groupsV3 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_groupsv3(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag groupsV3Create = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_groupsv3create(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag changeNumberV2 = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_changenumberv2(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      6, this->_internal_querystatusv3thumbnail(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag liveLocations = 7;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      7, this->_internal_livelocations(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag queryVname = 8;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      8, this->_internal_queryvname(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      9, this->_internal_voipindividualincoming(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_quickrepliesquery(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag payments = 11;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      11, this->_internal_payments(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag stickerPackQuery = 12;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      12, this->_internal_stickerpackquery(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      13, this->_internal_livelocationsfinal(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag labelsEdit = 14;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      14, this->_internal_labelsedit(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag mediaUpload = 15;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      15, this->_internal_mediaupload(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      18, this->_internal_mediauploadrichquickreplies(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag vnameV2 = 19;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      19, this->_internal_vnamev2(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      20, this->_internal_videoplaybackurl(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag statusRanking = 21;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      21, this->_internal_statusranking(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      22, this->_internal_voipindividualvideo(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      23, this->_internal_thirdpartystickers(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      24, this->_internal_frequentlyforwardedsetting(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      25, this->_internal_groupsv4joinpermission(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag recentStickers = 26;
+  if (cached_has_bits & 0x00800000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      26, this->_internal_recentstickers(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag catalog = 27;
+  if (cached_has_bits & 0x01000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      27, this->_internal_catalog(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag starredStickers = 28;
+  if (cached_has_bits & 0x02000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      28, this->_internal_starredstickers(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag voipGroupCall = 29;
+  if (cached_has_bits & 0x04000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      29, this->_internal_voipgroupcall(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag templateMessage = 30;
+  if (cached_has_bits & 0x08000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      30, this->_internal_templatemessage(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
+  if (cached_has_bits & 0x10000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      31, this->_internal_templatemessageinteractivity(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag ephemeralMessages = 32;
+  if (cached_has_bits & 0x20000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      32, this->_internal_ephemeralmessages(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
+  if (cached_has_bits & 0x40000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      33, this->_internal_e2enotificationsync(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag recentStickersV2 = 34;
+  if (cached_has_bits & 0x80000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      34, this->_internal_recentstickersv2(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional .proto.WebFeatures.Flag recentStickersV3 = 36;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      36, this->_internal_recentstickersv3(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag userNotice = 37;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      37, this->_internal_usernotice(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag support = 39;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      39, this->_internal_support(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      40, this->_internal_groupuiicleanup(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      41, this->_internal_groupdogfoodinginternalonly(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag settingsSync = 42;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      42, this->_internal_settingssync(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag archiveV2 = 43;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      43, this->_internal_archivev2(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      44, this->_internal_ephemeralallowgroupmembers(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      45, this->_internal_ephemeral24hduration(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      46, this->_internal_mdforceupgrade(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag disappearingMode = 47;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      47, this->_internal_disappearingmode(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      48, this->_internal_externalmdoptinavailable(), target);
+  }
+
+  // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      49, this->_internal_nodeletemessagetimelimit(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.WebFeatures)
+  return target;
+}
+
+size_t WebFeatures::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.WebFeatures)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.WebFeatures.Flag labelsDisplay = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsdisplay());
+    }
+
+    // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualoutgoing());
+    }
+
+    // optional .proto.WebFeatures.Flag groupsV3 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3());
+    }
+
+    // optional .proto.WebFeatures.Flag groupsV3Create = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3create());
+    }
+
+    // optional .proto.WebFeatures.Flag changeNumberV2 = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_changenumberv2());
+    }
+
+    // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_querystatusv3thumbnail());
+    }
+
+    // optional .proto.WebFeatures.Flag liveLocations = 7;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocations());
+    }
+
+    // optional .proto.WebFeatures.Flag queryVname = 8;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_queryvname());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualincoming());
+    }
+
+    // optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_quickrepliesquery());
+    }
+
+    // optional .proto.WebFeatures.Flag payments = 11;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_payments());
+    }
+
+    // optional .proto.WebFeatures.Flag stickerPackQuery = 12;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_stickerpackquery());
+    }
+
+    // optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocationsfinal());
+    }
+
+    // optional .proto.WebFeatures.Flag labelsEdit = 14;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsedit());
+    }
+
+    // optional .proto.WebFeatures.Flag mediaUpload = 15;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediaupload());
+    }
+
+    // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadrichquickreplies());
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional .proto.WebFeatures.Flag vnameV2 = 19;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_vnamev2());
+    }
+
+    // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_videoplaybackurl());
+    }
+
+    // optional .proto.WebFeatures.Flag statusRanking = 21;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_statusranking());
+    }
+
+    // optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualvideo());
+    }
+
+    // optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_thirdpartystickers());
+    }
+
+    // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_frequentlyforwardedsetting());
+    }
+
+    // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv4joinpermission());
+    }
+
+    // optional .proto.WebFeatures.Flag recentStickers = 26;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickers());
+    }
+
+  }
+  if (cached_has_bits & 0xff000000u) {
+    // optional .proto.WebFeatures.Flag catalog = 27;
+    if (cached_has_bits & 0x01000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_catalog());
+    }
+
+    // optional .proto.WebFeatures.Flag starredStickers = 28;
+    if (cached_has_bits & 0x02000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_starredstickers());
+    }
+
+    // optional .proto.WebFeatures.Flag voipGroupCall = 29;
+    if (cached_has_bits & 0x04000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_voipgroupcall());
+    }
+
+    // optional .proto.WebFeatures.Flag templateMessage = 30;
+    if (cached_has_bits & 0x08000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessage());
+    }
+
+    // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
+    if (cached_has_bits & 0x10000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessageinteractivity());
+    }
+
+    // optional .proto.WebFeatures.Flag ephemeralMessages = 32;
+    if (cached_has_bits & 0x20000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralmessages());
+    }
+
+    // optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
+    if (cached_has_bits & 0x40000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_e2enotificationsync());
+    }
+
+    // optional .proto.WebFeatures.Flag recentStickersV2 = 34;
+    if (cached_has_bits & 0x80000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv2());
+    }
+
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional .proto.WebFeatures.Flag recentStickersV3 = 36;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv3());
+    }
+
+    // optional .proto.WebFeatures.Flag userNotice = 37;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_usernotice());
+    }
+
+    // optional .proto.WebFeatures.Flag support = 39;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_support());
+    }
+
+    // optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_groupuiicleanup());
+    }
+
+    // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_groupdogfoodinginternalonly());
+    }
+
+    // optional .proto.WebFeatures.Flag settingsSync = 42;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_settingssync());
+    }
+
+    // optional .proto.WebFeatures.Flag archiveV2 = 43;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_archivev2());
+    }
+
+    // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralallowgroupmembers());
+    }
+
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeral24hduration());
+    }
+
+    // optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_mdforceupgrade());
+    }
+
+    // optional .proto.WebFeatures.Flag disappearingMode = 47;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_disappearingmode());
+    }
+
+    // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_externalmdoptinavailable());
+    }
+
+    // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_nodeletemessagetimelimit());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebFeatures::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    WebFeatures::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebFeatures::GetClassData() const { return &_class_data_; }
+
+
+void WebFeatures::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<WebFeatures*>(&to_msg);
+  auto& from = static_cast<const WebFeatures&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebFeatures)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.labelsdisplay_ = from._impl_.labelsdisplay_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.voipindividualoutgoing_ = from._impl_.voipindividualoutgoing_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.groupsv3_ = from._impl_.groupsv3_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.groupsv3create_ = from._impl_.groupsv3create_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.changenumberv2_ = from._impl_.changenumberv2_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.querystatusv3thumbnail_ = from._impl_.querystatusv3thumbnail_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.livelocations_ = from._impl_.livelocations_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.queryvname_ = from._impl_.queryvname_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.voipindividualincoming_ = from._impl_.voipindividualincoming_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.quickrepliesquery_ = from._impl_.quickrepliesquery_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.payments_ = from._impl_.payments_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.stickerpackquery_ = from._impl_.stickerpackquery_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.livelocationsfinal_ = from._impl_.livelocationsfinal_;
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.labelsedit_ = from._impl_.labelsedit_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.mediaupload_ = from._impl_.mediaupload_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.mediauploadrichquickreplies_ = from._impl_.mediauploadrichquickreplies_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.vnamev2_ = from._impl_.vnamev2_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.videoplaybackurl_ = from._impl_.videoplaybackurl_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.statusranking_ = from._impl_.statusranking_;
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.voipindividualvideo_ = from._impl_.voipindividualvideo_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.thirdpartystickers_ = from._impl_.thirdpartystickers_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.frequentlyforwardedsetting_ = from._impl_.frequentlyforwardedsetting_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.groupsv4joinpermission_ = from._impl_.groupsv4joinpermission_;
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_impl_.recentstickers_ = from._impl_.recentstickers_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0xff000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      _this->_impl_.catalog_ = from._impl_.catalog_;
+    }
+    if (cached_has_bits & 0x02000000u) {
+      _this->_impl_.starredstickers_ = from._impl_.starredstickers_;
+    }
+    if (cached_has_bits & 0x04000000u) {
+      _this->_impl_.voipgroupcall_ = from._impl_.voipgroupcall_;
+    }
+    if (cached_has_bits & 0x08000000u) {
+      _this->_impl_.templatemessage_ = from._impl_.templatemessage_;
+    }
+    if (cached_has_bits & 0x10000000u) {
+      _this->_impl_.templatemessageinteractivity_ = from._impl_.templatemessageinteractivity_;
+    }
+    if (cached_has_bits & 0x20000000u) {
+      _this->_impl_.ephemeralmessages_ = from._impl_.ephemeralmessages_;
+    }
+    if (cached_has_bits & 0x40000000u) {
+      _this->_impl_.e2enotificationsync_ = from._impl_.e2enotificationsync_;
+    }
+    if (cached_has_bits & 0x80000000u) {
+      _this->_impl_.recentstickersv2_ = from._impl_.recentstickersv2_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  cached_has_bits = from._impl_._has_bits_[1];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.recentstickersv3_ = from._impl_.recentstickersv3_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.usernotice_ = from._impl_.usernotice_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.support_ = from._impl_.support_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.groupuiicleanup_ = from._impl_.groupuiicleanup_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.groupdogfoodinginternalonly_ = from._impl_.groupdogfoodinginternalonly_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.settingssync_ = from._impl_.settingssync_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.archivev2_ = from._impl_.archivev2_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.ephemeralallowgroupmembers_ = from._impl_.ephemeralallowgroupmembers_;
+    }
+    _this->_impl_._has_bits_[1] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00001f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.ephemeral24hduration_ = from._impl_.ephemeral24hduration_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.mdforceupgrade_ = from._impl_.mdforceupgrade_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.disappearingmode_ = from._impl_.disappearingmode_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.externalmdoptinavailable_ = from._impl_.externalmdoptinavailable_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.nodeletemessagetimelimit_ = from._impl_.nodeletemessagetimelimit_;
+    }
+    _this->_impl_._has_bits_[1] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void WebFeatures::CopyFrom(const WebFeatures& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebFeatures)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WebFeatures::IsInitialized() const {
+  return true;
+}
+
+void WebFeatures::InternalSwap(WebFeatures* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.nodeletemessagetimelimit_)
+      + sizeof(WebFeatures::_impl_.nodeletemessagetimelimit_)
+      - PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.labelsdisplay_)>(
+          reinterpret_cast<char*>(&_impl_.labelsdisplay_),
+          reinterpret_cast<char*>(&other->_impl_.labelsdisplay_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WebFeatures::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[221]);
+}
+
+// ===================================================================
+
+class WebMessageInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<WebMessageInfo>()._impl_._has_bits_);
+  static const ::proto::MessageKey& key(const WebMessageInfo* msg);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::proto::Message& message(const WebMessageInfo* msg);
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_messagetimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 524288u;
+  }
+  static void set_has_status(HasBits* has_bits) {
+    (*has_bits)[0] |= 2097152u;
+  }
+  static void set_has_participant(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_messagec2stimestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1048576u;
+  }
+  static void set_has_ignore(HasBits* has_bits) {
+    (*has_bits)[0] |= 4194304u;
+  }
+  static void set_has_starred(HasBits* has_bits) {
+    (*has_bits)[0] |= 8388608u;
+  }
+  static void set_has_broadcast(HasBits* has_bits) {
+    (*has_bits)[0] |= 16777216u;
+  }
+  static void set_has_pushname(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_mediaciphertextsha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_multicast(HasBits* has_bits) {
+    (*has_bits)[0] |= 33554432u;
+  }
+  static void set_has_urltext(HasBits* has_bits) {
+    (*has_bits)[0] |= 134217728u;
+  }
+  static void set_has_urlnumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 268435456u;
+  }
+  static void set_has_messagestubtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 67108864u;
+  }
+  static void set_has_clearmedia(HasBits* has_bits) {
+    (*has_bits)[0] |= 536870912u;
+  }
+  static void set_has_duration(HasBits* has_bits) {
+    (*has_bits)[0] |= 2147483648u;
+  }
+  static const ::proto::PaymentInfo& paymentinfo(const WebMessageInfo* msg);
+  static void set_has_paymentinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static const ::proto::Message_LiveLocationMessage& finallivelocation(const WebMessageInfo* msg);
+  static void set_has_finallivelocation(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static const ::proto::PaymentInfo& quotedpaymentinfo(const WebMessageInfo* msg);
+  static void set_has_quotedpaymentinfo(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_ephemeralstarttimestamp(HasBits* has_bits) {
+    (*has_bits)[1] |= 2u;
+  }
+  static void set_has_ephemeralduration(HasBits* has_bits) {
+    (*has_bits)[1] |= 1u;
+  }
+  static void set_has_ephemeralofftoon(HasBits* has_bits) {
+    (*has_bits)[0] |= 1073741824u;
+  }
+  static void set_has_ephemeraloutofsync(HasBits* has_bits) {
+    (*has_bits)[1] |= 8u;
+  }
+  static void set_has_bizprivacystatus(HasBits* has_bits) {
+    (*has_bits)[1] |= 4u;
+  }
+  static void set_has_verifiedbizname(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::proto::MediaData& mediadata(const WebMessageInfo* msg);
+  static void set_has_mediadata(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static const ::proto::PhotoChange& photochange(const WebMessageInfo* msg);
+  static void set_has_photochange(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static const ::proto::MediaData& quotedstickerdata(const WebMessageInfo* msg);
+  static void set_has_quotedstickerdata(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_futureproofdata(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::proto::StatusPSA& statuspsa(const WebMessageInfo* msg);
+  static void set_has_statuspsa(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static const ::proto::PollAdditionalMetadata& polladditionalmetadata(const WebMessageInfo* msg);
+  static void set_has_polladditionalmetadata(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_agentid(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_statusalreadyviewed(HasBits* has_bits) {
+    (*has_bits)[1] |= 16u;
+  }
+  static void set_has_messagesecret(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::proto::KeepInChat& keepinchat(const WebMessageInfo* msg);
+  static void set_has_keepinchat(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_originalselfauthoruserjidstring(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_revokemessagetimestamp(HasBits* has_bits) {
+    (*has_bits)[1] |= 32u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000100) ^ 0x00000100) != 0;
+  }
+};
+
+const ::proto::MessageKey&
+WebMessageInfo::_Internal::key(const WebMessageInfo* msg) {
+  return *msg->_impl_.key_;
+}
+const ::proto::Message&
+WebMessageInfo::_Internal::message(const WebMessageInfo* msg) {
+  return *msg->_impl_.message_;
+}
+const ::proto::PaymentInfo&
+WebMessageInfo::_Internal::paymentinfo(const WebMessageInfo* msg) {
+  return *msg->_impl_.paymentinfo_;
+}
+const ::proto::Message_LiveLocationMessage&
+WebMessageInfo::_Internal::finallivelocation(const WebMessageInfo* msg) {
+  return *msg->_impl_.finallivelocation_;
+}
+const ::proto::PaymentInfo&
+WebMessageInfo::_Internal::quotedpaymentinfo(const WebMessageInfo* msg) {
+  return *msg->_impl_.quotedpaymentinfo_;
+}
+const ::proto::MediaData&
+WebMessageInfo::_Internal::mediadata(const WebMessageInfo* msg) {
+  return *msg->_impl_.mediadata_;
+}
+const ::proto::PhotoChange&
+WebMessageInfo::_Internal::photochange(const WebMessageInfo* msg) {
+  return *msg->_impl_.photochange_;
+}
+const ::proto::MediaData&
+WebMessageInfo::_Internal::quotedstickerdata(const WebMessageInfo* msg) {
+  return *msg->_impl_.quotedstickerdata_;
+}
+const ::proto::StatusPSA&
+WebMessageInfo::_Internal::statuspsa(const WebMessageInfo* msg) {
+  return *msg->_impl_.statuspsa_;
+}
+const ::proto::PollAdditionalMetadata&
+WebMessageInfo::_Internal::polladditionalmetadata(const WebMessageInfo* msg) {
+  return *msg->_impl_.polladditionalmetadata_;
+}
+const ::proto::KeepInChat&
+WebMessageInfo::_Internal::keepinchat(const WebMessageInfo* msg) {
+  return *msg->_impl_.keepinchat_;
+}
+WebMessageInfo::WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.WebMessageInfo)
+}
+WebMessageInfo::WebMessageInfo(const WebMessageInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  WebMessageInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagestubparameters_){from._impl_.messagestubparameters_}
+    , decltype(_impl_.labels_){from._impl_.labels_}
+    , decltype(_impl_.userreceipt_){from._impl_.userreceipt_}
+    , decltype(_impl_.reactions_){from._impl_.reactions_}
+    , decltype(_impl_.pollupdates_){from._impl_.pollupdates_}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.pushname_){}
+    , decltype(_impl_.mediaciphertextsha256_){}
+    , decltype(_impl_.verifiedbizname_){}
+    , decltype(_impl_.futureproofdata_){}
+    , decltype(_impl_.agentid_){}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.originalselfauthoruserjidstring_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.paymentinfo_){nullptr}
+    , decltype(_impl_.finallivelocation_){nullptr}
+    , decltype(_impl_.quotedpaymentinfo_){nullptr}
+    , decltype(_impl_.mediadata_){nullptr}
+    , decltype(_impl_.photochange_){nullptr}
+    , decltype(_impl_.quotedstickerdata_){nullptr}
+    , decltype(_impl_.statuspsa_){nullptr}
+    , decltype(_impl_.polladditionalmetadata_){nullptr}
+    , decltype(_impl_.keepinchat_){nullptr}
+    , decltype(_impl_.messagetimestamp_){}
+    , decltype(_impl_.messagec2stimestamp_){}
+    , decltype(_impl_.status_){}
+    , decltype(_impl_.ignore_){}
+    , decltype(_impl_.starred_){}
+    , decltype(_impl_.broadcast_){}
+    , decltype(_impl_.multicast_){}
+    , decltype(_impl_.messagestubtype_){}
+    , decltype(_impl_.urltext_){}
+    , decltype(_impl_.urlnumber_){}
+    , decltype(_impl_.clearmedia_){}
+    , decltype(_impl_.ephemeralofftoon_){}
+    , decltype(_impl_.duration_){}
+    , decltype(_impl_.ephemeralduration_){}
+    , decltype(_impl_.ephemeralstarttimestamp_){}
+    , decltype(_impl_.bizprivacystatus_){}
+    , decltype(_impl_.ephemeraloutofsync_){}
+    , decltype(_impl_.statusalreadyviewed_){}
+    , decltype(_impl_.revokemessagetimestamp_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_participant()) {
+    _this->_impl_.participant_.Set(from._internal_participant(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_pushname()) {
+    _this->_impl_.pushname_.Set(from._internal_pushname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mediaciphertextsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mediaciphertextsha256()) {
+    _this->_impl_.mediaciphertextsha256_.Set(from._internal_mediaciphertextsha256(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.verifiedbizname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_verifiedbizname()) {
+    _this->_impl_.verifiedbizname_.Set(from._internal_verifiedbizname(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.futureproofdata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_futureproofdata()) {
+    _this->_impl_.futureproofdata_.Set(from._internal_futureproofdata(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.agentid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.agentid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_agentid()) {
+    _this->_impl_.agentid_.Set(from._internal_agentid(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_messagesecret()) {
+    _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.originalselfauthoruserjidstring_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_originalselfauthoruserjidstring()) {
+    _this->_impl_.originalselfauthoruserjidstring_.Set(from._internal_originalselfauthoruserjidstring(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_key()) {
+    _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_);
+  }
+  if (from._internal_has_message()) {
+    _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_);
+  }
+  if (from._internal_has_paymentinfo()) {
+    _this->_impl_.paymentinfo_ = new ::proto::PaymentInfo(*from._impl_.paymentinfo_);
+  }
+  if (from._internal_has_finallivelocation()) {
+    _this->_impl_.finallivelocation_ = new ::proto::Message_LiveLocationMessage(*from._impl_.finallivelocation_);
+  }
+  if (from._internal_has_quotedpaymentinfo()) {
+    _this->_impl_.quotedpaymentinfo_ = new ::proto::PaymentInfo(*from._impl_.quotedpaymentinfo_);
+  }
+  if (from._internal_has_mediadata()) {
+    _this->_impl_.mediadata_ = new ::proto::MediaData(*from._impl_.mediadata_);
+  }
+  if (from._internal_has_photochange()) {
+    _this->_impl_.photochange_ = new ::proto::PhotoChange(*from._impl_.photochange_);
+  }
+  if (from._internal_has_quotedstickerdata()) {
+    _this->_impl_.quotedstickerdata_ = new ::proto::MediaData(*from._impl_.quotedstickerdata_);
+  }
+  if (from._internal_has_statuspsa()) {
+    _this->_impl_.statuspsa_ = new ::proto::StatusPSA(*from._impl_.statuspsa_);
+  }
+  if (from._internal_has_polladditionalmetadata()) {
+    _this->_impl_.polladditionalmetadata_ = new ::proto::PollAdditionalMetadata(*from._impl_.polladditionalmetadata_);
+  }
+  if (from._internal_has_keepinchat()) {
+    _this->_impl_.keepinchat_ = new ::proto::KeepInChat(*from._impl_.keepinchat_);
+  }
+  ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.revokemessagetimestamp_) -
+    reinterpret_cast<char*>(&_impl_.messagetimestamp_)) + sizeof(_impl_.revokemessagetimestamp_));
+  // @@protoc_insertion_point(copy_constructor:proto.WebMessageInfo)
+}
+
+inline void WebMessageInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.messagestubparameters_){arena}
+    , decltype(_impl_.labels_){arena}
+    , decltype(_impl_.userreceipt_){arena}
+    , decltype(_impl_.reactions_){arena}
+    , decltype(_impl_.pollupdates_){arena}
+    , decltype(_impl_.participant_){}
+    , decltype(_impl_.pushname_){}
+    , decltype(_impl_.mediaciphertextsha256_){}
+    , decltype(_impl_.verifiedbizname_){}
+    , decltype(_impl_.futureproofdata_){}
+    , decltype(_impl_.agentid_){}
+    , decltype(_impl_.messagesecret_){}
+    , decltype(_impl_.originalselfauthoruserjidstring_){}
+    , decltype(_impl_.key_){nullptr}
+    , decltype(_impl_.message_){nullptr}
+    , decltype(_impl_.paymentinfo_){nullptr}
+    , decltype(_impl_.finallivelocation_){nullptr}
+    , decltype(_impl_.quotedpaymentinfo_){nullptr}
+    , decltype(_impl_.mediadata_){nullptr}
+    , decltype(_impl_.photochange_){nullptr}
+    , decltype(_impl_.quotedstickerdata_){nullptr}
+    , decltype(_impl_.statuspsa_){nullptr}
+    , decltype(_impl_.polladditionalmetadata_){nullptr}
+    , decltype(_impl_.keepinchat_){nullptr}
+    , decltype(_impl_.messagetimestamp_){uint64_t{0u}}
+    , decltype(_impl_.messagec2stimestamp_){uint64_t{0u}}
+    , decltype(_impl_.status_){0}
+    , decltype(_impl_.ignore_){false}
+    , decltype(_impl_.starred_){false}
+    , decltype(_impl_.broadcast_){false}
+    , decltype(_impl_.multicast_){false}
+    , decltype(_impl_.messagestubtype_){0}
+    , decltype(_impl_.urltext_){false}
+    , decltype(_impl_.urlnumber_){false}
+    , decltype(_impl_.clearmedia_){false}
+    , decltype(_impl_.ephemeralofftoon_){false}
+    , decltype(_impl_.duration_){0u}
+    , decltype(_impl_.ephemeralduration_){0u}
+    , decltype(_impl_.ephemeralstarttimestamp_){uint64_t{0u}}
+    , decltype(_impl_.bizprivacystatus_){0}
+    , decltype(_impl_.ephemeraloutofsync_){false}
+    , decltype(_impl_.statusalreadyviewed_){false}
+    , decltype(_impl_.revokemessagetimestamp_){uint64_t{0u}}
+  };
+  _impl_.participant_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.pushname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mediaciphertextsha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.verifiedbizname_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.futureproofdata_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.agentid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.agentid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.messagesecret_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.originalselfauthoruserjidstring_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+WebMessageInfo::~WebMessageInfo() {
+  // @@protoc_insertion_point(destructor:proto.WebMessageInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void WebMessageInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.messagestubparameters_.~RepeatedPtrField();
+  _impl_.labels_.~RepeatedPtrField();
+  _impl_.userreceipt_.~RepeatedPtrField();
+  _impl_.reactions_.~RepeatedPtrField();
+  _impl_.pollupdates_.~RepeatedPtrField();
+  _impl_.participant_.Destroy();
+  _impl_.pushname_.Destroy();
+  _impl_.mediaciphertextsha256_.Destroy();
+  _impl_.verifiedbizname_.Destroy();
+  _impl_.futureproofdata_.Destroy();
+  _impl_.agentid_.Destroy();
+  _impl_.messagesecret_.Destroy();
+  _impl_.originalselfauthoruserjidstring_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.key_;
+  if (this != internal_default_instance()) delete _impl_.message_;
+  if (this != internal_default_instance()) delete _impl_.paymentinfo_;
+  if (this != internal_default_instance()) delete _impl_.finallivelocation_;
+  if (this != internal_default_instance()) delete _impl_.quotedpaymentinfo_;
+  if (this != internal_default_instance()) delete _impl_.mediadata_;
+  if (this != internal_default_instance()) delete _impl_.photochange_;
+  if (this != internal_default_instance()) delete _impl_.quotedstickerdata_;
+  if (this != internal_default_instance()) delete _impl_.statuspsa_;
+  if (this != internal_default_instance()) delete _impl_.polladditionalmetadata_;
+  if (this != internal_default_instance()) delete _impl_.keepinchat_;
+}
+
+void WebMessageInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void WebMessageInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.WebMessageInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.messagestubparameters_.Clear();
+  _impl_.labels_.Clear();
+  _impl_.userreceipt_.Clear();
+  _impl_.reactions_.Clear();
+  _impl_.pollupdates_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.participant_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.pushname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.mediaciphertextsha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.verifiedbizname_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.futureproofdata_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.agentid_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _impl_.messagesecret_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _impl_.originalselfauthoruserjidstring_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      GOOGLE_DCHECK(_impl_.key_ != nullptr);
+      _impl_.key_->Clear();
+    }
+    if (cached_has_bits & 0x00000200u) {
+      GOOGLE_DCHECK(_impl_.message_ != nullptr);
+      _impl_.message_->Clear();
+    }
+    if (cached_has_bits & 0x00000400u) {
+      GOOGLE_DCHECK(_impl_.paymentinfo_ != nullptr);
+      _impl_.paymentinfo_->Clear();
+    }
+    if (cached_has_bits & 0x00000800u) {
+      GOOGLE_DCHECK(_impl_.finallivelocation_ != nullptr);
+      _impl_.finallivelocation_->Clear();
+    }
+    if (cached_has_bits & 0x00001000u) {
+      GOOGLE_DCHECK(_impl_.quotedpaymentinfo_ != nullptr);
+      _impl_.quotedpaymentinfo_->Clear();
+    }
+    if (cached_has_bits & 0x00002000u) {
+      GOOGLE_DCHECK(_impl_.mediadata_ != nullptr);
+      _impl_.mediadata_->Clear();
+    }
+    if (cached_has_bits & 0x00004000u) {
+      GOOGLE_DCHECK(_impl_.photochange_ != nullptr);
+      _impl_.photochange_->Clear();
+    }
+    if (cached_has_bits & 0x00008000u) {
+      GOOGLE_DCHECK(_impl_.quotedstickerdata_ != nullptr);
+      _impl_.quotedstickerdata_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00070000u) {
+    if (cached_has_bits & 0x00010000u) {
+      GOOGLE_DCHECK(_impl_.statuspsa_ != nullptr);
+      _impl_.statuspsa_->Clear();
+    }
+    if (cached_has_bits & 0x00020000u) {
+      GOOGLE_DCHECK(_impl_.polladditionalmetadata_ != nullptr);
+      _impl_.polladditionalmetadata_->Clear();
+    }
+    if (cached_has_bits & 0x00040000u) {
+      GOOGLE_DCHECK(_impl_.keepinchat_ != nullptr);
+      _impl_.keepinchat_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00f80000u) {
+    ::memset(&_impl_.messagetimestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.starred_) -
+        reinterpret_cast<char*>(&_impl_.messagetimestamp_)) + sizeof(_impl_.starred_));
+  }
+  if (cached_has_bits & 0xff000000u) {
+    ::memset(&_impl_.broadcast_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.duration_) -
+        reinterpret_cast<char*>(&_impl_.broadcast_)) + sizeof(_impl_.duration_));
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    ::memset(&_impl_.ephemeralduration_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.revokemessagetimestamp_) -
+        reinterpret_cast<char*>(&_impl_.ephemeralduration_)) + sizeof(_impl_.revokemessagetimestamp_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WebMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required .proto.MessageKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_message(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 messageTimestamp = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_messagetimestamp(&_impl_._has_bits_);
+          _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebMessageInfo.Status status = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_Status_IsValid(val))) {
+            _internal_set_status(static_cast<::proto::WebMessageInfo_Status>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string participant = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_participant();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.participant");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 messageC2STimestamp = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_messagec2stimestamp(&_impl_._has_bits_);
+          _impl_.messagec2stimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool ignore = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_ignore(&_impl_._has_bits_);
+          _impl_.ignore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool starred = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
+          _Internal::set_has_starred(&_impl_._has_bits_);
+          _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool broadcast = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_broadcast(&_impl_._has_bits_);
+          _impl_.broadcast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string pushName = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_pushname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.pushName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes mediaCiphertextSha256 = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          auto str = _internal_mutable_mediaciphertextsha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool multicast = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
+          _Internal::set_has_multicast(&_impl_._has_bits_);
+          _impl_.multicast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool urlText = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
+          _Internal::set_has_urltext(&_impl_._has_bits_);
+          _impl_.urltext_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool urlNumber = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
+          _Internal::set_has_urlnumber(&_impl_._has_bits_);
+          _impl_.urlnumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebMessageInfo.StubType messageStubType = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_StubType_IsValid(val))) {
+            _internal_set_messagestubtype(static_cast<::proto::WebMessageInfo_StubType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool clearMedia = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
+          _Internal::set_has_clearmedia(&_impl_._has_bits_);
+          _impl_.clearmedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string messageStubParameters = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            auto str = _internal_add_messagestubparameters();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.messageStubParameters");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<210>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 duration = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
+          _Internal::set_has_duration(&_impl_._has_bits_);
+          _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string labels = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            auto str = _internal_add_labels();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            #ifndef NDEBUG
+            ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.labels");
+            #endif  // !NDEBUG
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<226>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentInfo paymentInfo = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_paymentinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
+          ptr = ctx->ParseMessage(_internal_mutable_finallivelocation(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PaymentInfo quotedPaymentInfo = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 250)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quotedpaymentinfo(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 ephemeralStartTimestamp = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
+          _Internal::set_has_ephemeralstarttimestamp(&_impl_._has_bits_);
+          _impl_.ephemeralstarttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 ephemeralDuration = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_ephemeralduration(&_impl_._has_bits_);
+          _impl_.ephemeralduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool ephemeralOffToOn = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_ephemeralofftoon(&_impl_._has_bits_);
+          _impl_.ephemeralofftoon_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool ephemeralOutOfSync = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_ephemeraloutofsync(&_impl_._has_bits_);
+          _impl_.ephemeraloutofsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(val))) {
+            _internal_set_bizprivacystatus(static_cast<::proto::WebMessageInfo_BizPrivacyStatus>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string verifiedBizName = 37;
+      case 37:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_verifiedbizname();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.verifiedBizName");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaData mediaData = 38;
+      case 38:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PhotoChange photoChange = 39;
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_photochange(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.UserReceipt userReceipt = 40;
+      case 40:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_userreceipt(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<322>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.Reaction reactions = 41;
+      case 41:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_reactions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<330>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.MediaData quotedStickerData = 42;
+      case 42:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_quotedstickerdata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes futureproofData = 43;
+      case 43:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_futureproofdata();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.StatusPSA statusPsa = 44;
+      case 44:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_statuspsa(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.PollUpdate pollUpdates = 45;
+      case 45:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_pollupdates(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<362>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
+      case 46:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_polladditionalmetadata(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string agentId = 47;
+      case 47:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          auto str = _internal_mutable_agentid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.agentId");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool statusAlreadyViewed = 48;
+      case 48:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_statusalreadyviewed(&_impl_._has_bits_);
+          _impl_.statusalreadyviewed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes messageSecret = 49;
+      case 49:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          auto str = _internal_mutable_messagesecret();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .proto.KeepInChat keepInChat = 50;
+      case 50:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr = ctx->ParseMessage(_internal_mutable_keepinchat(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string originalSelfAuthorUserJidString = 51;
+      case 51:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_originalselfauthoruserjidstring();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.originalSelfAuthorUserJidString");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 revokeMessageTimestamp = 52;
+      case 52:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
+          _Internal::set_has_revokemessagetimestamp(&_impl_._has_bits_);
+          _impl_.revokemessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* WebMessageInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.WebMessageInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required .proto.MessageKey key = 1;
+  if (cached_has_bits & 0x00000100u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::key(this),
+        _Internal::key(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message message = 2;
+  if (cached_has_bits & 0x00000200u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::message(this),
+        _Internal::message(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint64 messageTimestamp = 3;
+  if (cached_has_bits & 0x00080000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target);
+  }
+
+  // optional .proto.WebMessageInfo.Status status = 4;
+  if (cached_has_bits & 0x00200000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_status(), target);
+  }
+
+  // optional string participant = 5;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_participant().data(), static_cast<int>(this->_internal_participant().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.participant");
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_participant(), target);
+  }
+
+  // optional uint64 messageC2STimestamp = 6;
+  if (cached_has_bits & 0x00100000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_messagec2stimestamp(), target);
+  }
+
+  // optional bool ignore = 16;
+  if (cached_has_bits & 0x00400000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_ignore(), target);
+  }
+
+  // optional bool starred = 17;
+  if (cached_has_bits & 0x00800000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(17, this->_internal_starred(), target);
+  }
+
+  // optional bool broadcast = 18;
+  if (cached_has_bits & 0x01000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_broadcast(), target);
+  }
+
+  // optional string pushName = 19;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_pushname().data(), static_cast<int>(this->_internal_pushname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.pushName");
+    target = stream->WriteStringMaybeAliased(
+        19, this->_internal_pushname(), target);
+  }
+
+  // optional bytes mediaCiphertextSha256 = 20;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        20, this->_internal_mediaciphertextsha256(), target);
+  }
+
+  // optional bool multicast = 21;
+  if (cached_has_bits & 0x02000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(21, this->_internal_multicast(), target);
+  }
+
+  // optional bool urlText = 22;
+  if (cached_has_bits & 0x08000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_urltext(), target);
+  }
+
+  // optional bool urlNumber = 23;
+  if (cached_has_bits & 0x10000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_urlnumber(), target);
+  }
+
+  // optional .proto.WebMessageInfo.StubType messageStubType = 24;
+  if (cached_has_bits & 0x04000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      24, this->_internal_messagestubtype(), target);
+  }
+
+  // optional bool clearMedia = 25;
+  if (cached_has_bits & 0x20000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_clearmedia(), target);
+  }
+
+  // repeated string messageStubParameters = 26;
+  for (int i = 0, n = this->_internal_messagestubparameters_size(); i < n; i++) {
+    const auto& s = this->_internal_messagestubparameters(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.messageStubParameters");
+    target = stream->WriteString(26, s, target);
+  }
+
+  // optional uint32 duration = 27;
+  if (cached_has_bits & 0x80000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(27, this->_internal_duration(), target);
+  }
+
+  // repeated string labels = 28;
+  for (int i = 0, n = this->_internal_labels_size(); i < n; i++) {
+    const auto& s = this->_internal_labels(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.labels");
+    target = stream->WriteString(28, s, target);
+  }
+
+  // optional .proto.PaymentInfo paymentInfo = 29;
+  if (cached_has_bits & 0x00000400u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(29, _Internal::paymentinfo(this),
+        _Internal::paymentinfo(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
+  if (cached_has_bits & 0x00000800u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(30, _Internal::finallivelocation(this),
+        _Internal::finallivelocation(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PaymentInfo quotedPaymentInfo = 31;
+  if (cached_has_bits & 0x00001000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(31, _Internal::quotedpaymentinfo(this),
+        _Internal::quotedpaymentinfo(this).GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional uint64 ephemeralStartTimestamp = 32;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(32, this->_internal_ephemeralstarttimestamp(), target);
+  }
+
+  // optional uint32 ephemeralDuration = 33;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(33, this->_internal_ephemeralduration(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool ephemeralOffToOn = 34;
+  if (cached_has_bits & 0x40000000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_ephemeralofftoon(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional bool ephemeralOutOfSync = 35;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_ephemeraloutofsync(), target);
+  }
+
+  // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      36, this->_internal_bizprivacystatus(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string verifiedBizName = 37;
+  if (cached_has_bits & 0x00000008u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_verifiedbizname().data(), static_cast<int>(this->_internal_verifiedbizname().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.verifiedBizName");
+    target = stream->WriteStringMaybeAliased(
+        37, this->_internal_verifiedbizname(), target);
+  }
+
+  // optional .proto.MediaData mediaData = 38;
+  if (cached_has_bits & 0x00002000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(38, _Internal::mediadata(this),
+        _Internal::mediadata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PhotoChange photoChange = 39;
+  if (cached_has_bits & 0x00004000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(39, _Internal::photochange(this),
+        _Internal::photochange(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.UserReceipt userReceipt = 40;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_userreceipt_size()); i < n; i++) {
+    const auto& repfield = this->_internal_userreceipt(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(40, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.Reaction reactions = 41;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_reactions_size()); i < n; i++) {
+    const auto& repfield = this->_internal_reactions(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(41, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.MediaData quotedStickerData = 42;
+  if (cached_has_bits & 0x00008000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(42, _Internal::quotedstickerdata(this),
+        _Internal::quotedstickerdata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes futureproofData = 43;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        43, this->_internal_futureproofdata(), target);
+  }
+
+  // optional .proto.StatusPSA statusPsa = 44;
+  if (cached_has_bits & 0x00010000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(44, _Internal::statuspsa(this),
+        _Internal::statuspsa(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .proto.PollUpdate pollUpdates = 45;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_pollupdates_size()); i < n; i++) {
+    const auto& repfield = this->_internal_pollupdates(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(45, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
+  if (cached_has_bits & 0x00020000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(46, _Internal::polladditionalmetadata(this),
+        _Internal::polladditionalmetadata(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string agentId = 47;
+  if (cached_has_bits & 0x00000020u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_agentid().data(), static_cast<int>(this->_internal_agentid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.agentId");
+    target = stream->WriteStringMaybeAliased(
+        47, this->_internal_agentid(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional bool statusAlreadyViewed = 48;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(48, this->_internal_statusalreadyviewed(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes messageSecret = 49;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->WriteBytesMaybeAliased(
+        49, this->_internal_messagesecret(), target);
+  }
+
+  // optional .proto.KeepInChat keepInChat = 50;
+  if (cached_has_bits & 0x00040000u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(50, _Internal::keepinchat(this),
+        _Internal::keepinchat(this).GetCachedSize(), target, stream);
+  }
+
+  // optional string originalSelfAuthorUserJidString = 51;
+  if (cached_has_bits & 0x00000080u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_originalselfauthoruserjidstring().data(), static_cast<int>(this->_internal_originalselfauthoruserjidstring().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "proto.WebMessageInfo.originalSelfAuthorUserJidString");
+    target = stream->WriteStringMaybeAliased(
+        51, this->_internal_originalselfauthoruserjidstring(), target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[1];
+  // optional uint64 revokeMessageTimestamp = 52;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(52, this->_internal_revokemessagetimestamp(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.WebMessageInfo)
+  return target;
+}
+
+size_t WebMessageInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.WebMessageInfo)
+  size_t total_size = 0;
+
+  // required .proto.MessageKey key = 1;
+  if (_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.key_);
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string messageStubParameters = 26;
+  total_size += 2 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.messagestubparameters_.size());
+  for (int i = 0, n = _impl_.messagestubparameters_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.messagestubparameters_.Get(i));
+  }
+
+  // repeated string labels = 28;
+  total_size += 2 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.labels_.size());
+  for (int i = 0, n = _impl_.labels_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.labels_.Get(i));
+  }
+
+  // repeated .proto.UserReceipt userReceipt = 40;
+  total_size += 2UL * this->_internal_userreceipt_size();
+  for (const auto& msg : this->_impl_.userreceipt_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.Reaction reactions = 41;
+  total_size += 2UL * this->_internal_reactions_size();
+  for (const auto& msg : this->_impl_.reactions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .proto.PollUpdate pollUpdates = 45;
+  total_size += 2UL * this->_internal_pollupdates_size();
+  for (const auto& msg : this->_impl_.pollupdates_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string participant = 5;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_participant());
+    }
+
+    // optional string pushName = 19;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_pushname());
+    }
+
+    // optional bytes mediaCiphertextSha256 = 20;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_mediaciphertextsha256());
+    }
+
+    // optional string verifiedBizName = 37;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_verifiedbizname());
+    }
+
+    // optional bytes futureproofData = 43;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_futureproofdata());
+    }
+
+    // optional string agentId = 47;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_agentid());
+    }
+
+    // optional bytes messageSecret = 49;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_messagesecret());
+    }
+
+    // optional string originalSelfAuthorUserJidString = 51;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_originalselfauthoruserjidstring());
+    }
+
+  }
+  if (cached_has_bits & 0x0000fe00u) {
+    // optional .proto.Message message = 2;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.message_);
+    }
+
+    // optional .proto.PaymentInfo paymentInfo = 29;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.paymentinfo_);
+    }
+
+    // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.finallivelocation_);
+    }
+
+    // optional .proto.PaymentInfo quotedPaymentInfo = 31;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quotedpaymentinfo_);
+    }
+
+    // optional .proto.MediaData mediaData = 38;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.mediadata_);
+    }
+
+    // optional .proto.PhotoChange photoChange = 39;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.photochange_);
+    }
+
+    // optional .proto.MediaData quotedStickerData = 42;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.quotedstickerdata_);
+    }
+
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    // optional .proto.StatusPSA statusPsa = 44;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.statuspsa_);
+    }
+
+    // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.polladditionalmetadata_);
+    }
+
+    // optional .proto.KeepInChat keepInChat = 50;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.keepinchat_);
+    }
+
+    // optional uint64 messageTimestamp = 3;
+    if (cached_has_bits & 0x00080000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp());
+    }
+
+    // optional uint64 messageC2STimestamp = 6;
+    if (cached_has_bits & 0x00100000u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagec2stimestamp());
+    }
+
+    // optional .proto.WebMessageInfo.Status status = 4;
+    if (cached_has_bits & 0x00200000u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
+    }
+
+    // optional bool ignore = 16;
+    if (cached_has_bits & 0x00400000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool starred = 17;
+    if (cached_has_bits & 0x00800000u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0xff000000u) {
+    // optional bool broadcast = 18;
+    if (cached_has_bits & 0x01000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool multicast = 21;
+    if (cached_has_bits & 0x02000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional .proto.WebMessageInfo.StubType messageStubType = 24;
+    if (cached_has_bits & 0x04000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_messagestubtype());
+    }
+
+    // optional bool urlText = 22;
+    if (cached_has_bits & 0x08000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool urlNumber = 23;
+    if (cached_has_bits & 0x10000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool clearMedia = 25;
+    if (cached_has_bits & 0x20000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool ephemeralOffToOn = 34;
+    if (cached_has_bits & 0x40000000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint32 duration = 27;
+    if (cached_has_bits & 0x80000000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_duration());
+    }
+
+  }
+  cached_has_bits = _impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional uint32 ephemeralDuration = 33;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt32Size(
+          this->_internal_ephemeralduration());
+    }
+
+    // optional uint64 ephemeralStartTimestamp = 32;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_ephemeralstarttimestamp());
+    }
+
+    // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_bizprivacystatus());
+    }
+
+    // optional bool ephemeralOutOfSync = 35;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool statusAlreadyViewed = 48;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint64 revokeMessageTimestamp = 52;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::UInt64Size(
+          this->_internal_revokemessagetimestamp());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebMessageInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    WebMessageInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebMessageInfo::GetClassData() const { return &_class_data_; }
+
+
+void WebMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<WebMessageInfo*>(&to_msg);
+  auto& from = static_cast<const WebMessageInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebMessageInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.messagestubparameters_.MergeFrom(from._impl_.messagestubparameters_);
+  _this->_impl_.labels_.MergeFrom(from._impl_.labels_);
+  _this->_impl_.userreceipt_.MergeFrom(from._impl_.userreceipt_);
+  _this->_impl_.reactions_.MergeFrom(from._impl_.reactions_);
+  _this->_impl_.pollupdates_.MergeFrom(from._impl_.pollupdates_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_participant(from._internal_participant());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_pushname(from._internal_pushname());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_mediaciphertextsha256(from._internal_mediaciphertextsha256());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_verifiedbizname(from._internal_verifiedbizname());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_futureproofdata(from._internal_futureproofdata());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_agentid(from._internal_agentid());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_set_messagesecret(from._internal_messagesecret());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_set_originalselfauthoruserjidstring(from._internal_originalselfauthoruserjidstring());
+    }
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom(
+          from._internal_key());
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_internal_mutable_message()->::proto::Message::MergeFrom(
+          from._internal_message());
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_internal_mutable_paymentinfo()->::proto::PaymentInfo::MergeFrom(
+          from._internal_paymentinfo());
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_internal_mutable_finallivelocation()->::proto::Message_LiveLocationMessage::MergeFrom(
+          from._internal_finallivelocation());
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_internal_mutable_quotedpaymentinfo()->::proto::PaymentInfo::MergeFrom(
+          from._internal_quotedpaymentinfo());
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_internal_mutable_mediadata()->::proto::MediaData::MergeFrom(
+          from._internal_mediadata());
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_internal_mutable_photochange()->::proto::PhotoChange::MergeFrom(
+          from._internal_photochange());
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_internal_mutable_quotedstickerdata()->::proto::MediaData::MergeFrom(
+          from._internal_quotedstickerdata());
+    }
+  }
+  if (cached_has_bits & 0x00ff0000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_internal_mutable_statuspsa()->::proto::StatusPSA::MergeFrom(
+          from._internal_statuspsa());
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_internal_mutable_polladditionalmetadata()->::proto::PollAdditionalMetadata::MergeFrom(
+          from._internal_polladditionalmetadata());
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_internal_mutable_keepinchat()->::proto::KeepInChat::MergeFrom(
+          from._internal_keepinchat());
+    }
+    if (cached_has_bits & 0x00080000u) {
+      _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_;
+    }
+    if (cached_has_bits & 0x00100000u) {
+      _this->_impl_.messagec2stimestamp_ = from._impl_.messagec2stimestamp_;
+    }
+    if (cached_has_bits & 0x00200000u) {
+      _this->_impl_.status_ = from._impl_.status_;
+    }
+    if (cached_has_bits & 0x00400000u) {
+      _this->_impl_.ignore_ = from._impl_.ignore_;
+    }
+    if (cached_has_bits & 0x00800000u) {
+      _this->_impl_.starred_ = from._impl_.starred_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0xff000000u) {
+    if (cached_has_bits & 0x01000000u) {
+      _this->_impl_.broadcast_ = from._impl_.broadcast_;
+    }
+    if (cached_has_bits & 0x02000000u) {
+      _this->_impl_.multicast_ = from._impl_.multicast_;
+    }
+    if (cached_has_bits & 0x04000000u) {
+      _this->_impl_.messagestubtype_ = from._impl_.messagestubtype_;
+    }
+    if (cached_has_bits & 0x08000000u) {
+      _this->_impl_.urltext_ = from._impl_.urltext_;
+    }
+    if (cached_has_bits & 0x10000000u) {
+      _this->_impl_.urlnumber_ = from._impl_.urlnumber_;
+    }
+    if (cached_has_bits & 0x20000000u) {
+      _this->_impl_.clearmedia_ = from._impl_.clearmedia_;
+    }
+    if (cached_has_bits & 0x40000000u) {
+      _this->_impl_.ephemeralofftoon_ = from._impl_.ephemeralofftoon_;
+    }
+    if (cached_has_bits & 0x80000000u) {
+      _this->_impl_.duration_ = from._impl_.duration_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  cached_has_bits = from._impl_._has_bits_[1];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.ephemeralduration_ = from._impl_.ephemeralduration_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.ephemeralstarttimestamp_ = from._impl_.ephemeralstarttimestamp_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.bizprivacystatus_ = from._impl_.bizprivacystatus_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.ephemeraloutofsync_ = from._impl_.ephemeraloutofsync_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.statusalreadyviewed_ = from._impl_.statusalreadyviewed_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.revokemessagetimestamp_ = from._impl_.revokemessagetimestamp_;
+    }
+    _this->_impl_._has_bits_[1] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void WebMessageInfo::CopyFrom(const WebMessageInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebMessageInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WebMessageInfo::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.userreceipt_))
+    return false;
+  if (_internal_has_statuspsa()) {
+    if (!_impl_.statuspsa_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void WebMessageInfo::InternalSwap(WebMessageInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]);
+  _impl_.messagestubparameters_.InternalSwap(&other->_impl_.messagestubparameters_);
+  _impl_.labels_.InternalSwap(&other->_impl_.labels_);
+  _impl_.userreceipt_.InternalSwap(&other->_impl_.userreceipt_);
+  _impl_.reactions_.InternalSwap(&other->_impl_.reactions_);
+  _impl_.pollupdates_.InternalSwap(&other->_impl_.pollupdates_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.participant_, lhs_arena,
+      &other->_impl_.participant_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.pushname_, lhs_arena,
+      &other->_impl_.pushname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mediaciphertextsha256_, lhs_arena,
+      &other->_impl_.mediaciphertextsha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.verifiedbizname_, lhs_arena,
+      &other->_impl_.verifiedbizname_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.futureproofdata_, lhs_arena,
+      &other->_impl_.futureproofdata_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.agentid_, lhs_arena,
+      &other->_impl_.agentid_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.messagesecret_, lhs_arena,
+      &other->_impl_.messagesecret_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.originalselfauthoruserjidstring_, lhs_arena,
+      &other->_impl_.originalselfauthoruserjidstring_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.revokemessagetimestamp_)
+      + sizeof(WebMessageInfo::_impl_.revokemessagetimestamp_)
+      - PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.key_)>(
+          reinterpret_cast<char*>(&_impl_.key_),
+          reinterpret_cast<char*>(&other->_impl_.key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WebMessageInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[222]);
+}
+
+// ===================================================================
+
+class WebNotificationsInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<WebNotificationsInfo>()._impl_._has_bits_);
+  static void set_has_timestamp(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_unreadchats(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_notifymessagecount(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+WebNotificationsInfo::WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:proto.WebNotificationsInfo)
+}
+WebNotificationsInfo::WebNotificationsInfo(const WebNotificationsInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  WebNotificationsInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notifymessages_){from._impl_.notifymessages_}
+    , decltype(_impl_.timestamp_){}
+    , decltype(_impl_.unreadchats_){}
+    , decltype(_impl_.notifymessagecount_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.notifymessagecount_) -
+    reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_));
+  // @@protoc_insertion_point(copy_constructor:proto.WebNotificationsInfo)
+}
+
+inline void WebNotificationsInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notifymessages_){arena}
+    , decltype(_impl_.timestamp_){uint64_t{0u}}
+    , decltype(_impl_.unreadchats_){0u}
+    , decltype(_impl_.notifymessagecount_){0u}
+  };
+}
+
+WebNotificationsInfo::~WebNotificationsInfo() {
+  // @@protoc_insertion_point(destructor:proto.WebNotificationsInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void WebNotificationsInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.notifymessages_.~RepeatedPtrField();
+}
+
+void WebNotificationsInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void WebNotificationsInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.WebNotificationsInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.notifymessages_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.notifymessagecount_) -
+        reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WebNotificationsInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 timestamp = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_timestamp(&has_bits);
+          _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 unreadChats = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_unreadchats(&has_bits);
+          _impl_.unreadchats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 notifyMessageCount = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_notifymessagecount(&has_bits);
+          _impl_.notifymessagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .proto.WebMessageInfo notifyMessages = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_notifymessages(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* WebNotificationsInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:proto.WebNotificationsInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 timestamp = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target);
+  }
+
+  // optional uint32 unreadChats = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_unreadchats(), target);
+  }
+
+  // optional uint32 notifyMessageCount = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_notifymessagecount(), target);
+  }
+
+  // repeated .proto.WebMessageInfo notifyMessages = 5;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_notifymessages_size()); i < n; i++) {
+    const auto& repfield = this->_internal_notifymessages(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::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:proto.WebNotificationsInfo)
+  return target;
+}
+
+size_t WebNotificationsInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.WebNotificationsInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .proto.WebMessageInfo notifyMessages = 5;
+  total_size += 1UL * this->_internal_notifymessages_size();
+  for (const auto& msg : this->_impl_.notifymessages_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional uint64 timestamp = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp());
+    }
+
+    // optional uint32 unreadChats = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadchats());
+    }
+
+    // optional uint32 notifyMessageCount = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_notifymessagecount());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebNotificationsInfo::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    WebNotificationsInfo::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebNotificationsInfo::GetClassData() const { return &_class_data_; }
+
+
+void WebNotificationsInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<WebNotificationsInfo*>(&to_msg);
+  auto& from = static_cast<const WebNotificationsInfo&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebNotificationsInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.notifymessages_.MergeFrom(from._impl_.notifymessages_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.timestamp_ = from._impl_.timestamp_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.unreadchats_ = from._impl_.unreadchats_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.notifymessagecount_ = from._impl_.notifymessagecount_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void WebNotificationsInfo::CopyFrom(const WebNotificationsInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebNotificationsInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WebNotificationsInfo::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.notifymessages_))
+    return false;
+  return true;
+}
+
+void WebNotificationsInfo::InternalSwap(WebNotificationsInfo* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.notifymessages_.InternalSwap(&other->_impl_.notifymessages_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.notifymessagecount_)
+      + sizeof(WebNotificationsInfo::_impl_.notifymessagecount_)
+      - PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.timestamp_)>(
+          reinterpret_cast<char*>(&_impl_.timestamp_),
+          reinterpret_cast<char*>(&other->_impl_.timestamp_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WebNotificationsInfo::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once,
+      file_level_metadata_pmsg_2eproto[223]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace proto
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::proto::ADVDeviceIdentity*
+Arena::CreateMaybeMessage< ::proto::ADVDeviceIdentity >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ADVDeviceIdentity >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ADVKeyIndexList*
+Arena::CreateMaybeMessage< ::proto::ADVKeyIndexList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ADVKeyIndexList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentity*
+Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentity >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentity >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentityHMAC*
+Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentityHMAC >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentityHMAC >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ADVSignedKeyIndexList*
+Arena::CreateMaybeMessage< ::proto::ADVSignedKeyIndexList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ADVSignedKeyIndexList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ActionLink*
+Arena::CreateMaybeMessage< ::proto::ActionLink >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ActionLink >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::AutoDownloadSettings*
+Arena::CreateMaybeMessage< ::proto::AutoDownloadSettings >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::AutoDownloadSettings >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::BizAccountLinkInfo*
+Arena::CreateMaybeMessage< ::proto::BizAccountLinkInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::BizAccountLinkInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::BizAccountPayload*
+Arena::CreateMaybeMessage< ::proto::BizAccountPayload >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::BizAccountPayload >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::BizIdentityInfo*
+Arena::CreateMaybeMessage< ::proto::BizIdentityInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::BizIdentityInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate_Details*
+Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate_Details >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate_Details >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate*
+Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::CertChain*
+Arena::CreateMaybeMessage< ::proto::CertChain >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::CertChain >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Chain*
+Arena::CreateMaybeMessage< ::proto::Chain >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Chain >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ChainKey*
+Arena::CreateMaybeMessage< ::proto::ChainKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ChainKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DNSSource*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_DNSSource >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_DNSSource >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DevicePairingRegistrationData*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_DevicePairingRegistrationData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_DevicePairingRegistrationData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent_AppVersion*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent_AppVersion >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent_AppVersion >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo_WebdPayload*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo_WebdPayload >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo_WebdPayload >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo*
+Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ClientPayload*
+Arena::CreateMaybeMessage< ::proto::ClientPayload >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ClientPayload >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ContextInfo_AdReplyInfo*
+Arena::CreateMaybeMessage< ::proto::ContextInfo_AdReplyInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ContextInfo_AdReplyInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ContextInfo_ExternalAdReplyInfo*
+Arena::CreateMaybeMessage< ::proto::ContextInfo_ExternalAdReplyInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ContextInfo_ExternalAdReplyInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ContextInfo*
+Arena::CreateMaybeMessage< ::proto::ContextInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ContextInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Conversation*
+Arena::CreateMaybeMessage< ::proto::Conversation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Conversation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::DeviceListMetadata*
+Arena::CreateMaybeMessage< ::proto::DeviceListMetadata >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::DeviceListMetadata >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::DeviceProps_AppVersion*
+Arena::CreateMaybeMessage< ::proto::DeviceProps_AppVersion >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::DeviceProps_AppVersion >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::DeviceProps*
+Arena::CreateMaybeMessage< ::proto::DeviceProps >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::DeviceProps >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::DisappearingMode*
+Arena::CreateMaybeMessage< ::proto::DisappearingMode >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::DisappearingMode >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::EphemeralSetting*
+Arena::CreateMaybeMessage< ::proto::EphemeralSetting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::EphemeralSetting >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ExitCode*
+Arena::CreateMaybeMessage< ::proto::ExitCode >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ExitCode >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ExternalBlobReference*
+Arena::CreateMaybeMessage< ::proto::ExternalBlobReference >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ExternalBlobReference >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::GlobalSettings*
+Arena::CreateMaybeMessage< ::proto::GlobalSettings >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::GlobalSettings >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::GroupParticipant*
+Arena::CreateMaybeMessage< ::proto::GroupParticipant >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::GroupParticipant >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientFinish*
+Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientFinish >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientFinish >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientHello*
+Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientHello >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientHello >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ServerHello*
+Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ServerHello >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ServerHello >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage*
+Arena::CreateMaybeMessage< ::proto::HandshakeMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HandshakeMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HistorySync*
+Arena::CreateMaybeMessage< ::proto::HistorySync >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HistorySync >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HistorySyncMsg*
+Arena::CreateMaybeMessage< ::proto::HistorySyncMsg >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HistorySyncMsg >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedCallButton*
+Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedCallButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedQuickReplyButton*
+Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedURLButton*
+Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedURLButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton*
+Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::IdentityKeyPairStructure*
+Arena::CreateMaybeMessage< ::proto::IdentityKeyPairStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::IdentityKeyPairStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::InteractiveAnnotation*
+Arena::CreateMaybeMessage< ::proto::InteractiveAnnotation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::InteractiveAnnotation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::KeepInChat*
+Arena::CreateMaybeMessage< ::proto::KeepInChat >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::KeepInChat >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::KeyId*
+Arena::CreateMaybeMessage< ::proto::KeyId >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::KeyId >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::LocalizedName*
+Arena::CreateMaybeMessage< ::proto::LocalizedName >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::LocalizedName >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Location*
+Arena::CreateMaybeMessage< ::proto::Location >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Location >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MediaData*
+Arena::CreateMaybeMessage< ::proto::MediaData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MediaData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MediaRetryNotification*
+Arena::CreateMaybeMessage< ::proto::MediaRetryNotification >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MediaRetryNotification >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateFatalExceptionNotification*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateFatalExceptionNotification >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateFatalExceptionNotification >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyData*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyFingerprint*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyFingerprint >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyFingerprint >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyId*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyId >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyId >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyRequest*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyShare*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyShare >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyShare >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKey*
+Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_AudioMessage*
+Arena::CreateMaybeMessage< ::proto::Message_AudioMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_AudioMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_ButtonText*
+Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_ButtonText >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_ButtonText >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_NativeFlowInfo*
+Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button*
+Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsResponseMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ButtonsResponseMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ButtonsResponseMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_Call*
+Arena::CreateMaybeMessage< ::proto::Message_Call >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_Call >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_CancelPaymentRequestMessage*
+Arena::CreateMaybeMessage< ::proto::Message_CancelPaymentRequestMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_CancelPaymentRequestMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_Chat*
+Arena::CreateMaybeMessage< ::proto::Message_Chat >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_Chat >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ContactMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ContactMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ContactMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ContactsArrayMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ContactsArrayMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ContactsArrayMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_DeclinePaymentRequestMessage*
+Arena::CreateMaybeMessage< ::proto::Message_DeclinePaymentRequestMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_DeclinePaymentRequestMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_DeviceSentMessage*
+Arena::CreateMaybeMessage< ::proto::Message_DeviceSentMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_DeviceSentMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_DocumentMessage*
+Arena::CreateMaybeMessage< ::proto::Message_DocumentMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_DocumentMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ExtendedTextMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ExtendedTextMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ExtendedTextMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_FutureProofMessage*
+Arena::CreateMaybeMessage< ::proto::Message_FutureProofMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_FutureProofMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_GroupInviteMessage*
+Arena::CreateMaybeMessage< ::proto::Message_GroupInviteMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_GroupInviteMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage*
+Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_HistorySyncNotification*
+Arena::CreateMaybeMessage< ::proto::Message_HistorySyncNotification >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_HistorySyncNotification >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ImageMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ImageMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ImageMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InitialSecurityNotificationSettingSync*
+Arena::CreateMaybeMessage< ::proto::Message_InitialSecurityNotificationSettingSync >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InitialSecurityNotificationSettingSync >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Body*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Body >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Body >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_CollectionMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_CollectionMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Footer*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Footer >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Footer >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Header*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Header >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Header >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_ShopMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_ShopMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_Body*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_Body >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_Body >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_InvoiceMessage*
+Arena::CreateMaybeMessage< ::proto::Message_InvoiceMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_InvoiceMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_KeepInChatMessage*
+Arena::CreateMaybeMessage< ::proto::Message_KeepInChatMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_KeepInChatMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListHeaderImage*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListHeaderImage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListHeaderImage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListInfo*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductSection*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductSection >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductSection >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Product*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Product >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Product >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Row*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Row >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Row >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Section*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Section >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Section >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ListMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage_SingleSelectReply*
+Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage_SingleSelectReply >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage_SingleSelectReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_LiveLocationMessage*
+Arena::CreateMaybeMessage< ::proto::Message_LiveLocationMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_LiveLocationMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_LocationMessage*
+Arena::CreateMaybeMessage< ::proto::Message_LocationMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_LocationMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_OrderMessage*
+Arena::CreateMaybeMessage< ::proto::Message_OrderMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_OrderMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PaymentInviteMessage*
+Arena::CreateMaybeMessage< ::proto::Message_PaymentInviteMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PaymentInviteMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage_Option*
+Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage_Option >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage_Option >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage*
+Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollEncValue*
+Arena::CreateMaybeMessage< ::proto::Message_PollEncValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollEncValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessageMetadata*
+Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessageMetadata >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessageMetadata >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessage*
+Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_PollVoteMessage*
+Arena::CreateMaybeMessage< ::proto::Message_PollVoteMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_PollVoteMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_CatalogSnapshot*
+Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_CatalogSnapshot >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_CatalogSnapshot >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_ProductSnapshot*
+Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_ProductSnapshot >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_ProductSnapshot >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ProductMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ProductMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ProtocolMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ProtocolMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ProtocolMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_ReactionMessage*
+Arena::CreateMaybeMessage< ::proto::Message_ReactionMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_ReactionMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadMessage*
+Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult*
+Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage*
+Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_RequestPaymentMessage*
+Arena::CreateMaybeMessage< ::proto::Message_RequestPaymentMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_RequestPaymentMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_RequestPhoneNumberMessage*
+Arena::CreateMaybeMessage< ::proto::Message_RequestPhoneNumberMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_RequestPhoneNumberMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_SendPaymentMessage*
+Arena::CreateMaybeMessage< ::proto::Message_SendPaymentMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_SendPaymentMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_SenderKeyDistributionMessage*
+Arena::CreateMaybeMessage< ::proto::Message_SenderKeyDistributionMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_SenderKeyDistributionMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_StickerMessage*
+Arena::CreateMaybeMessage< ::proto::Message_StickerMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_StickerMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_StickerSyncRMRMessage*
+Arena::CreateMaybeMessage< ::proto::Message_StickerSyncRMRMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_StickerSyncRMRMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_TemplateButtonReplyMessage*
+Arena::CreateMaybeMessage< ::proto::Message_TemplateButtonReplyMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_TemplateButtonReplyMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_FourRowTemplate*
+Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_FourRowTemplate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_HydratedFourRowTemplate*
+Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage*
+Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message_VideoMessage*
+Arena::CreateMaybeMessage< ::proto::Message_VideoMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message_VideoMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Message*
+Arena::CreateMaybeMessage< ::proto::Message >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Message >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MessageContextInfo*
+Arena::CreateMaybeMessage< ::proto::MessageContextInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MessageContextInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MessageKey*
+Arena::CreateMaybeMessage< ::proto::MessageKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MessageKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Money*
+Arena::CreateMaybeMessage< ::proto::Money >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Money >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData_PollOption*
+Arena::CreateMaybeMessage< ::proto::MsgOpaqueData_PollOption >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MsgOpaqueData_PollOption >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData*
+Arena::CreateMaybeMessage< ::proto::MsgOpaqueData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MsgOpaqueData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::MsgRowOpaqueData*
+Arena::CreateMaybeMessage< ::proto::MsgRowOpaqueData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::MsgRowOpaqueData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate_Details*
+Arena::CreateMaybeMessage< ::proto::NoiseCertificate_Details >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::NoiseCertificate_Details >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate*
+Arena::CreateMaybeMessage< ::proto::NoiseCertificate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::NoiseCertificate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::NotificationMessageInfo*
+Arena::CreateMaybeMessage< ::proto::NotificationMessageInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::NotificationMessageInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PastParticipant*
+Arena::CreateMaybeMessage< ::proto::PastParticipant >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PastParticipant >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PastParticipants*
+Arena::CreateMaybeMessage< ::proto::PastParticipants >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PastParticipants >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PaymentBackground_MediaData*
+Arena::CreateMaybeMessage< ::proto::PaymentBackground_MediaData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PaymentBackground_MediaData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PaymentBackground*
+Arena::CreateMaybeMessage< ::proto::PaymentBackground >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PaymentBackground >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PaymentInfo*
+Arena::CreateMaybeMessage< ::proto::PaymentInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PaymentInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PendingKeyExchange*
+Arena::CreateMaybeMessage< ::proto::PendingKeyExchange >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PendingKeyExchange >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PendingPreKey*
+Arena::CreateMaybeMessage< ::proto::PendingPreKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PendingPreKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PhotoChange*
+Arena::CreateMaybeMessage< ::proto::PhotoChange >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PhotoChange >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Point*
+Arena::CreateMaybeMessage< ::proto::Point >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Point >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PollAdditionalMetadata*
+Arena::CreateMaybeMessage< ::proto::PollAdditionalMetadata >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PollAdditionalMetadata >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PollEncValue*
+Arena::CreateMaybeMessage< ::proto::PollEncValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PollEncValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PollUpdate*
+Arena::CreateMaybeMessage< ::proto::PollUpdate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PollUpdate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::PreKeyRecordStructure*
+Arena::CreateMaybeMessage< ::proto::PreKeyRecordStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::PreKeyRecordStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Pushname*
+Arena::CreateMaybeMessage< ::proto::Pushname >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Pushname >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::Reaction*
+Arena::CreateMaybeMessage< ::proto::Reaction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::Reaction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::RecentEmojiWeight*
+Arena::CreateMaybeMessage< ::proto::RecentEmojiWeight >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::RecentEmojiWeight >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::RecordStructure*
+Arena::CreateMaybeMessage< ::proto::RecordStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::RecordStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SenderChainKey*
+Arena::CreateMaybeMessage< ::proto::SenderChainKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SenderChainKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SenderKeyRecordStructure*
+Arena::CreateMaybeMessage< ::proto::SenderKeyRecordStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SenderKeyRecordStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SenderKeyStateStructure*
+Arena::CreateMaybeMessage< ::proto::SenderKeyStateStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SenderKeyStateStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SenderMessageKey*
+Arena::CreateMaybeMessage< ::proto::SenderMessageKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SenderMessageKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SenderSigningKey*
+Arena::CreateMaybeMessage< ::proto::SenderSigningKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SenderSigningKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ServerErrorReceipt*
+Arena::CreateMaybeMessage< ::proto::ServerErrorReceipt >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::ServerErrorReceipt >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SessionStructure*
+Arena::CreateMaybeMessage< ::proto::SessionStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SessionStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SignedPreKeyRecordStructure*
+Arena::CreateMaybeMessage< ::proto::SignedPreKeyRecordStructure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SignedPreKeyRecordStructure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::StatusPSA*
+Arena::CreateMaybeMessage< ::proto::StatusPSA >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::StatusPSA >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::StickerMetadata*
+Arena::CreateMaybeMessage< ::proto::StickerMetadata >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::StickerMetadata >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionData*
+Arena::CreateMaybeMessage< ::proto::SyncActionData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AgentAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_AgentAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_AgentAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AndroidUnsupportedActions*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_AndroidUnsupportedActions >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_AndroidUnsupportedActions >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ArchiveChatAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_ArchiveChatAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_ArchiveChatAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ClearChatAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_ClearChatAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_ClearChatAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ContactAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_ContactAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_ContactAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteChatAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteChatAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteChatAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteMessageForMeAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteMessageForMeAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteMessageForMeAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_KeyExpiration*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_KeyExpiration >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_KeyExpiration >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelAssociationAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelAssociationAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelAssociationAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelEditAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelEditAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelEditAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LocaleSetting*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_LocaleSetting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_LocaleSetting >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MarkChatAsReadAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_MarkChatAsReadAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_MarkChatAsReadAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MuteAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_MuteAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_MuteAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_NuxAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_NuxAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_NuxAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PinAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_PinAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_PinAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryFeature*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryFeature >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryFeature >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryVersionAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryVersionAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryVersionAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PushNameSetting*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_PushNameSetting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_PushNameSetting >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_QuickReplyAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_QuickReplyAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_QuickReplyAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_RecentEmojiWeightsAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_RecentEmojiWeightsAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_RecentEmojiWeightsAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SecurityNotificationSetting*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_SecurityNotificationSetting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_SecurityNotificationSetting >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StarAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_StarAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_StarAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StickerAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_StickerAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_StickerAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SubscriptionAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_SubscriptionAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_SubscriptionAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessageRange*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessageRange >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessageRange >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessage*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_TimeFormatAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_TimeFormatAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_TimeFormatAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UnarchiveChatsSetting*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_UnarchiveChatsSetting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_UnarchiveChatsSetting >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UserStatusMuteAction*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue_UserStatusMuteAction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue_UserStatusMuteAction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncActionValue*
+Arena::CreateMaybeMessage< ::proto::SyncActionValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncActionValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdIndex*
+Arena::CreateMaybeMessage< ::proto::SyncdIndex >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdIndex >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdMutation*
+Arena::CreateMaybeMessage< ::proto::SyncdMutation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdMutation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdMutations*
+Arena::CreateMaybeMessage< ::proto::SyncdMutations >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdMutations >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdPatch*
+Arena::CreateMaybeMessage< ::proto::SyncdPatch >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdPatch >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdRecord*
+Arena::CreateMaybeMessage< ::proto::SyncdRecord >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdRecord >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdSnapshot*
+Arena::CreateMaybeMessage< ::proto::SyncdSnapshot >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdSnapshot >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdValue*
+Arena::CreateMaybeMessage< ::proto::SyncdValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::SyncdVersion*
+Arena::CreateMaybeMessage< ::proto::SyncdVersion >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::SyncdVersion >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::TemplateButton_CallButton*
+Arena::CreateMaybeMessage< ::proto::TemplateButton_CallButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::TemplateButton_CallButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::TemplateButton_QuickReplyButton*
+Arena::CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::TemplateButton_QuickReplyButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::TemplateButton_URLButton*
+Arena::CreateMaybeMessage< ::proto::TemplateButton_URLButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::TemplateButton_URLButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::TemplateButton*
+Arena::CreateMaybeMessage< ::proto::TemplateButton >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::TemplateButton >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::UserReceipt*
+Arena::CreateMaybeMessage< ::proto::UserReceipt >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::UserReceipt >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate_Details*
+Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate_Details >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate_Details >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate*
+Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::WallpaperSettings*
+Arena::CreateMaybeMessage< ::proto::WallpaperSettings >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::WallpaperSettings >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::WebFeatures*
+Arena::CreateMaybeMessage< ::proto::WebFeatures >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::WebFeatures >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::WebMessageInfo*
+Arena::CreateMaybeMessage< ::proto::WebMessageInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::WebMessageInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::WebNotificationsInfo*
+Arena::CreateMaybeMessage< ::proto::WebNotificationsInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::proto::WebNotificationsInfo >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/protocols/WhatsApp/src/pmsg.pb.h b/protocols/WhatsApp/src/pmsg.pb.h
new file mode 100644
index 0000000000..5402ec1abf
--- /dev/null
+++ b/protocols/WhatsApp/src/pmsg.pb.h
@@ -0,0 +1,125385 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: pmsg.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#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 3021004 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_pmsg_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_pmsg_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_pmsg_2eproto;
+namespace proto {
+class ADVDeviceIdentity;
+struct ADVDeviceIdentityDefaultTypeInternal;
+extern ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_;
+class ADVKeyIndexList;
+struct ADVKeyIndexListDefaultTypeInternal;
+extern ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_;
+class ADVSignedDeviceIdentity;
+struct ADVSignedDeviceIdentityDefaultTypeInternal;
+extern ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_;
+class ADVSignedDeviceIdentityHMAC;
+struct ADVSignedDeviceIdentityHMACDefaultTypeInternal;
+extern ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_;
+class ADVSignedKeyIndexList;
+struct ADVSignedKeyIndexListDefaultTypeInternal;
+extern ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_;
+class ActionLink;
+struct ActionLinkDefaultTypeInternal;
+extern ActionLinkDefaultTypeInternal _ActionLink_default_instance_;
+class AutoDownloadSettings;
+struct AutoDownloadSettingsDefaultTypeInternal;
+extern AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_;
+class BizAccountLinkInfo;
+struct BizAccountLinkInfoDefaultTypeInternal;
+extern BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_;
+class BizAccountPayload;
+struct BizAccountPayloadDefaultTypeInternal;
+extern BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_;
+class BizIdentityInfo;
+struct BizIdentityInfoDefaultTypeInternal;
+extern BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_;
+class CertChain;
+struct CertChainDefaultTypeInternal;
+extern CertChainDefaultTypeInternal _CertChain_default_instance_;
+class CertChain_NoiseCertificate;
+struct CertChain_NoiseCertificateDefaultTypeInternal;
+extern CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_;
+class CertChain_NoiseCertificate_Details;
+struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal;
+extern CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_;
+class Chain;
+struct ChainDefaultTypeInternal;
+extern ChainDefaultTypeInternal _Chain_default_instance_;
+class ChainKey;
+struct ChainKeyDefaultTypeInternal;
+extern ChainKeyDefaultTypeInternal _ChainKey_default_instance_;
+class ClientPayload;
+struct ClientPayloadDefaultTypeInternal;
+extern ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_;
+class ClientPayload_DNSSource;
+struct ClientPayload_DNSSourceDefaultTypeInternal;
+extern ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_;
+class ClientPayload_DevicePairingRegistrationData;
+struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal;
+extern ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_;
+class ClientPayload_UserAgent;
+struct ClientPayload_UserAgentDefaultTypeInternal;
+extern ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_;
+class ClientPayload_UserAgent_AppVersion;
+struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal;
+extern ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_;
+class ClientPayload_WebInfo;
+struct ClientPayload_WebInfoDefaultTypeInternal;
+extern ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_;
+class ClientPayload_WebInfo_WebdPayload;
+struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal;
+extern ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_;
+class ContextInfo;
+struct ContextInfoDefaultTypeInternal;
+extern ContextInfoDefaultTypeInternal _ContextInfo_default_instance_;
+class ContextInfo_AdReplyInfo;
+struct ContextInfo_AdReplyInfoDefaultTypeInternal;
+extern ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_;
+class ContextInfo_ExternalAdReplyInfo;
+struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal;
+extern ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_;
+class Conversation;
+struct ConversationDefaultTypeInternal;
+extern ConversationDefaultTypeInternal _Conversation_default_instance_;
+class DeviceListMetadata;
+struct DeviceListMetadataDefaultTypeInternal;
+extern DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_;
+class DeviceProps;
+struct DevicePropsDefaultTypeInternal;
+extern DevicePropsDefaultTypeInternal _DeviceProps_default_instance_;
+class DeviceProps_AppVersion;
+struct DeviceProps_AppVersionDefaultTypeInternal;
+extern DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_;
+class DisappearingMode;
+struct DisappearingModeDefaultTypeInternal;
+extern DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_;
+class EphemeralSetting;
+struct EphemeralSettingDefaultTypeInternal;
+extern EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_;
+class ExitCode;
+struct ExitCodeDefaultTypeInternal;
+extern ExitCodeDefaultTypeInternal _ExitCode_default_instance_;
+class ExternalBlobReference;
+struct ExternalBlobReferenceDefaultTypeInternal;
+extern ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_;
+class GlobalSettings;
+struct GlobalSettingsDefaultTypeInternal;
+extern GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_;
+class GroupParticipant;
+struct GroupParticipantDefaultTypeInternal;
+extern GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_;
+class HandshakeMessage;
+struct HandshakeMessageDefaultTypeInternal;
+extern HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_;
+class HandshakeMessage_ClientFinish;
+struct HandshakeMessage_ClientFinishDefaultTypeInternal;
+extern HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_;
+class HandshakeMessage_ClientHello;
+struct HandshakeMessage_ClientHelloDefaultTypeInternal;
+extern HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_;
+class HandshakeMessage_ServerHello;
+struct HandshakeMessage_ServerHelloDefaultTypeInternal;
+extern HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_;
+class HistorySync;
+struct HistorySyncDefaultTypeInternal;
+extern HistorySyncDefaultTypeInternal _HistorySync_default_instance_;
+class HistorySyncMsg;
+struct HistorySyncMsgDefaultTypeInternal;
+extern HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_;
+class HydratedTemplateButton;
+struct HydratedTemplateButtonDefaultTypeInternal;
+extern HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_;
+class HydratedTemplateButton_HydratedCallButton;
+struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal;
+extern HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_;
+class HydratedTemplateButton_HydratedQuickReplyButton;
+struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal;
+extern HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_;
+class HydratedTemplateButton_HydratedURLButton;
+struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal;
+extern HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_;
+class IdentityKeyPairStructure;
+struct IdentityKeyPairStructureDefaultTypeInternal;
+extern IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_;
+class InteractiveAnnotation;
+struct InteractiveAnnotationDefaultTypeInternal;
+extern InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_;
+class KeepInChat;
+struct KeepInChatDefaultTypeInternal;
+extern KeepInChatDefaultTypeInternal _KeepInChat_default_instance_;
+class KeyId;
+struct KeyIdDefaultTypeInternal;
+extern KeyIdDefaultTypeInternal _KeyId_default_instance_;
+class LocalizedName;
+struct LocalizedNameDefaultTypeInternal;
+extern LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_;
+class Location;
+struct LocationDefaultTypeInternal;
+extern LocationDefaultTypeInternal _Location_default_instance_;
+class MediaData;
+struct MediaDataDefaultTypeInternal;
+extern MediaDataDefaultTypeInternal _MediaData_default_instance_;
+class MediaRetryNotification;
+struct MediaRetryNotificationDefaultTypeInternal;
+extern MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_;
+class Message;
+struct MessageDefaultTypeInternal;
+extern MessageDefaultTypeInternal _Message_default_instance_;
+class MessageContextInfo;
+struct MessageContextInfoDefaultTypeInternal;
+extern MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_;
+class MessageKey;
+struct MessageKeyDefaultTypeInternal;
+extern MessageKeyDefaultTypeInternal _MessageKey_default_instance_;
+class Message_AppStateFatalExceptionNotification;
+struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal;
+extern Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_;
+class Message_AppStateSyncKey;
+struct Message_AppStateSyncKeyDefaultTypeInternal;
+extern Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_;
+class Message_AppStateSyncKeyData;
+struct Message_AppStateSyncKeyDataDefaultTypeInternal;
+extern Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_;
+class Message_AppStateSyncKeyFingerprint;
+struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal;
+extern Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_;
+class Message_AppStateSyncKeyId;
+struct Message_AppStateSyncKeyIdDefaultTypeInternal;
+extern Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_;
+class Message_AppStateSyncKeyRequest;
+struct Message_AppStateSyncKeyRequestDefaultTypeInternal;
+extern Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_;
+class Message_AppStateSyncKeyShare;
+struct Message_AppStateSyncKeyShareDefaultTypeInternal;
+extern Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_;
+class Message_AudioMessage;
+struct Message_AudioMessageDefaultTypeInternal;
+extern Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_;
+class Message_ButtonsMessage;
+struct Message_ButtonsMessageDefaultTypeInternal;
+extern Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_;
+class Message_ButtonsMessage_Button;
+struct Message_ButtonsMessage_ButtonDefaultTypeInternal;
+extern Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_;
+class Message_ButtonsMessage_Button_ButtonText;
+struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal;
+extern Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_;
+class Message_ButtonsMessage_Button_NativeFlowInfo;
+struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal;
+extern Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_;
+class Message_ButtonsResponseMessage;
+struct Message_ButtonsResponseMessageDefaultTypeInternal;
+extern Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_;
+class Message_Call;
+struct Message_CallDefaultTypeInternal;
+extern Message_CallDefaultTypeInternal _Message_Call_default_instance_;
+class Message_CancelPaymentRequestMessage;
+struct Message_CancelPaymentRequestMessageDefaultTypeInternal;
+extern Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_;
+class Message_Chat;
+struct Message_ChatDefaultTypeInternal;
+extern Message_ChatDefaultTypeInternal _Message_Chat_default_instance_;
+class Message_ContactMessage;
+struct Message_ContactMessageDefaultTypeInternal;
+extern Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_;
+class Message_ContactsArrayMessage;
+struct Message_ContactsArrayMessageDefaultTypeInternal;
+extern Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_;
+class Message_DeclinePaymentRequestMessage;
+struct Message_DeclinePaymentRequestMessageDefaultTypeInternal;
+extern Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_;
+class Message_DeviceSentMessage;
+struct Message_DeviceSentMessageDefaultTypeInternal;
+extern Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_;
+class Message_DocumentMessage;
+struct Message_DocumentMessageDefaultTypeInternal;
+extern Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_;
+class Message_ExtendedTextMessage;
+struct Message_ExtendedTextMessageDefaultTypeInternal;
+extern Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_;
+class Message_FutureProofMessage;
+struct Message_FutureProofMessageDefaultTypeInternal;
+extern Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_;
+class Message_GroupInviteMessage;
+struct Message_GroupInviteMessageDefaultTypeInternal;
+extern Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_;
+class Message_HighlyStructuredMessage;
+struct Message_HighlyStructuredMessageDefaultTypeInternal;
+extern Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_;
+class Message_HighlyStructuredMessage_HSMLocalizableParameter;
+struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal;
+extern Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_;
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency;
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal;
+extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_;
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime;
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal;
+extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_;
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent;
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal;
+extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_;
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch;
+struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal;
+extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_;
+class Message_HistorySyncNotification;
+struct Message_HistorySyncNotificationDefaultTypeInternal;
+extern Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_;
+class Message_ImageMessage;
+struct Message_ImageMessageDefaultTypeInternal;
+extern Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_;
+class Message_InitialSecurityNotificationSettingSync;
+struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal;
+extern Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_;
+class Message_InteractiveMessage;
+struct Message_InteractiveMessageDefaultTypeInternal;
+extern Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_;
+class Message_InteractiveMessage_Body;
+struct Message_InteractiveMessage_BodyDefaultTypeInternal;
+extern Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_;
+class Message_InteractiveMessage_CollectionMessage;
+struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal;
+extern Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_;
+class Message_InteractiveMessage_Footer;
+struct Message_InteractiveMessage_FooterDefaultTypeInternal;
+extern Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_;
+class Message_InteractiveMessage_Header;
+struct Message_InteractiveMessage_HeaderDefaultTypeInternal;
+extern Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_;
+class Message_InteractiveMessage_NativeFlowMessage;
+struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal;
+extern Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_;
+class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton;
+struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal;
+extern Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_;
+class Message_InteractiveMessage_ShopMessage;
+struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal;
+extern Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_;
+class Message_InteractiveResponseMessage;
+struct Message_InteractiveResponseMessageDefaultTypeInternal;
+extern Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_;
+class Message_InteractiveResponseMessage_Body;
+struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal;
+extern Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_;
+class Message_InteractiveResponseMessage_NativeFlowResponseMessage;
+struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal;
+extern Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_;
+class Message_InvoiceMessage;
+struct Message_InvoiceMessageDefaultTypeInternal;
+extern Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_;
+class Message_KeepInChatMessage;
+struct Message_KeepInChatMessageDefaultTypeInternal;
+extern Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_;
+class Message_ListMessage;
+struct Message_ListMessageDefaultTypeInternal;
+extern Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_;
+class Message_ListMessage_Product;
+struct Message_ListMessage_ProductDefaultTypeInternal;
+extern Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_;
+class Message_ListMessage_ProductListHeaderImage;
+struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal;
+extern Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_;
+class Message_ListMessage_ProductListInfo;
+struct Message_ListMessage_ProductListInfoDefaultTypeInternal;
+extern Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_;
+class Message_ListMessage_ProductSection;
+struct Message_ListMessage_ProductSectionDefaultTypeInternal;
+extern Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_;
+class Message_ListMessage_Row;
+struct Message_ListMessage_RowDefaultTypeInternal;
+extern Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_;
+class Message_ListMessage_Section;
+struct Message_ListMessage_SectionDefaultTypeInternal;
+extern Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_;
+class Message_ListResponseMessage;
+struct Message_ListResponseMessageDefaultTypeInternal;
+extern Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_;
+class Message_ListResponseMessage_SingleSelectReply;
+struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal;
+extern Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_;
+class Message_LiveLocationMessage;
+struct Message_LiveLocationMessageDefaultTypeInternal;
+extern Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_;
+class Message_LocationMessage;
+struct Message_LocationMessageDefaultTypeInternal;
+extern Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_;
+class Message_OrderMessage;
+struct Message_OrderMessageDefaultTypeInternal;
+extern Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_;
+class Message_PaymentInviteMessage;
+struct Message_PaymentInviteMessageDefaultTypeInternal;
+extern Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_;
+class Message_PollCreationMessage;
+struct Message_PollCreationMessageDefaultTypeInternal;
+extern Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_;
+class Message_PollCreationMessage_Option;
+struct Message_PollCreationMessage_OptionDefaultTypeInternal;
+extern Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_;
+class Message_PollEncValue;
+struct Message_PollEncValueDefaultTypeInternal;
+extern Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_;
+class Message_PollUpdateMessage;
+struct Message_PollUpdateMessageDefaultTypeInternal;
+extern Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_;
+class Message_PollUpdateMessageMetadata;
+struct Message_PollUpdateMessageMetadataDefaultTypeInternal;
+extern Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_;
+class Message_PollVoteMessage;
+struct Message_PollVoteMessageDefaultTypeInternal;
+extern Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_;
+class Message_ProductMessage;
+struct Message_ProductMessageDefaultTypeInternal;
+extern Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_;
+class Message_ProductMessage_CatalogSnapshot;
+struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal;
+extern Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_;
+class Message_ProductMessage_ProductSnapshot;
+struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal;
+extern Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_;
+class Message_ProtocolMessage;
+struct Message_ProtocolMessageDefaultTypeInternal;
+extern Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_;
+class Message_ReactionMessage;
+struct Message_ReactionMessageDefaultTypeInternal;
+extern Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_;
+class Message_RequestMediaUploadMessage;
+struct Message_RequestMediaUploadMessageDefaultTypeInternal;
+extern Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_;
+class Message_RequestMediaUploadResponseMessage;
+struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal;
+extern Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_;
+class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult;
+struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal;
+extern Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_;
+class Message_RequestPaymentMessage;
+struct Message_RequestPaymentMessageDefaultTypeInternal;
+extern Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_;
+class Message_RequestPhoneNumberMessage;
+struct Message_RequestPhoneNumberMessageDefaultTypeInternal;
+extern Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_;
+class Message_SendPaymentMessage;
+struct Message_SendPaymentMessageDefaultTypeInternal;
+extern Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_;
+class Message_SenderKeyDistributionMessage;
+struct Message_SenderKeyDistributionMessageDefaultTypeInternal;
+extern Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_;
+class Message_StickerMessage;
+struct Message_StickerMessageDefaultTypeInternal;
+extern Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_;
+class Message_StickerSyncRMRMessage;
+struct Message_StickerSyncRMRMessageDefaultTypeInternal;
+extern Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_;
+class Message_TemplateButtonReplyMessage;
+struct Message_TemplateButtonReplyMessageDefaultTypeInternal;
+extern Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_;
+class Message_TemplateMessage;
+struct Message_TemplateMessageDefaultTypeInternal;
+extern Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_;
+class Message_TemplateMessage_FourRowTemplate;
+struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal;
+extern Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_;
+class Message_TemplateMessage_HydratedFourRowTemplate;
+struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal;
+extern Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_;
+class Message_VideoMessage;
+struct Message_VideoMessageDefaultTypeInternal;
+extern Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_;
+class Money;
+struct MoneyDefaultTypeInternal;
+extern MoneyDefaultTypeInternal _Money_default_instance_;
+class MsgOpaqueData;
+struct MsgOpaqueDataDefaultTypeInternal;
+extern MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_;
+class MsgOpaqueData_PollOption;
+struct MsgOpaqueData_PollOptionDefaultTypeInternal;
+extern MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_;
+class MsgRowOpaqueData;
+struct MsgRowOpaqueDataDefaultTypeInternal;
+extern MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_;
+class NoiseCertificate;
+struct NoiseCertificateDefaultTypeInternal;
+extern NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_;
+class NoiseCertificate_Details;
+struct NoiseCertificate_DetailsDefaultTypeInternal;
+extern NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_;
+class NotificationMessageInfo;
+struct NotificationMessageInfoDefaultTypeInternal;
+extern NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_;
+class PastParticipant;
+struct PastParticipantDefaultTypeInternal;
+extern PastParticipantDefaultTypeInternal _PastParticipant_default_instance_;
+class PastParticipants;
+struct PastParticipantsDefaultTypeInternal;
+extern PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_;
+class PaymentBackground;
+struct PaymentBackgroundDefaultTypeInternal;
+extern PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_;
+class PaymentBackground_MediaData;
+struct PaymentBackground_MediaDataDefaultTypeInternal;
+extern PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_;
+class PaymentInfo;
+struct PaymentInfoDefaultTypeInternal;
+extern PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_;
+class PendingKeyExchange;
+struct PendingKeyExchangeDefaultTypeInternal;
+extern PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_;
+class PendingPreKey;
+struct PendingPreKeyDefaultTypeInternal;
+extern PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_;
+class PhotoChange;
+struct PhotoChangeDefaultTypeInternal;
+extern PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_;
+class Point;
+struct PointDefaultTypeInternal;
+extern PointDefaultTypeInternal _Point_default_instance_;
+class PollAdditionalMetadata;
+struct PollAdditionalMetadataDefaultTypeInternal;
+extern PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_;
+class PollEncValue;
+struct PollEncValueDefaultTypeInternal;
+extern PollEncValueDefaultTypeInternal _PollEncValue_default_instance_;
+class PollUpdate;
+struct PollUpdateDefaultTypeInternal;
+extern PollUpdateDefaultTypeInternal _PollUpdate_default_instance_;
+class PreKeyRecordStructure;
+struct PreKeyRecordStructureDefaultTypeInternal;
+extern PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_;
+class Pushname;
+struct PushnameDefaultTypeInternal;
+extern PushnameDefaultTypeInternal _Pushname_default_instance_;
+class Reaction;
+struct ReactionDefaultTypeInternal;
+extern ReactionDefaultTypeInternal _Reaction_default_instance_;
+class RecentEmojiWeight;
+struct RecentEmojiWeightDefaultTypeInternal;
+extern RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_;
+class RecordStructure;
+struct RecordStructureDefaultTypeInternal;
+extern RecordStructureDefaultTypeInternal _RecordStructure_default_instance_;
+class SenderChainKey;
+struct SenderChainKeyDefaultTypeInternal;
+extern SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_;
+class SenderKeyRecordStructure;
+struct SenderKeyRecordStructureDefaultTypeInternal;
+extern SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_;
+class SenderKeyStateStructure;
+struct SenderKeyStateStructureDefaultTypeInternal;
+extern SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_;
+class SenderMessageKey;
+struct SenderMessageKeyDefaultTypeInternal;
+extern SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_;
+class SenderSigningKey;
+struct SenderSigningKeyDefaultTypeInternal;
+extern SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_;
+class ServerErrorReceipt;
+struct ServerErrorReceiptDefaultTypeInternal;
+extern ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_;
+class SessionStructure;
+struct SessionStructureDefaultTypeInternal;
+extern SessionStructureDefaultTypeInternal _SessionStructure_default_instance_;
+class SignedPreKeyRecordStructure;
+struct SignedPreKeyRecordStructureDefaultTypeInternal;
+extern SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_;
+class StatusPSA;
+struct StatusPSADefaultTypeInternal;
+extern StatusPSADefaultTypeInternal _StatusPSA_default_instance_;
+class StickerMetadata;
+struct StickerMetadataDefaultTypeInternal;
+extern StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_;
+class SyncActionData;
+struct SyncActionDataDefaultTypeInternal;
+extern SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_;
+class SyncActionValue;
+struct SyncActionValueDefaultTypeInternal;
+extern SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_;
+class SyncActionValue_AgentAction;
+struct SyncActionValue_AgentActionDefaultTypeInternal;
+extern SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_;
+class SyncActionValue_AndroidUnsupportedActions;
+struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal;
+extern SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_;
+class SyncActionValue_ArchiveChatAction;
+struct SyncActionValue_ArchiveChatActionDefaultTypeInternal;
+extern SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_;
+class SyncActionValue_ClearChatAction;
+struct SyncActionValue_ClearChatActionDefaultTypeInternal;
+extern SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_;
+class SyncActionValue_ContactAction;
+struct SyncActionValue_ContactActionDefaultTypeInternal;
+extern SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_;
+class SyncActionValue_DeleteChatAction;
+struct SyncActionValue_DeleteChatActionDefaultTypeInternal;
+extern SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_;
+class SyncActionValue_DeleteMessageForMeAction;
+struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal;
+extern SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_;
+class SyncActionValue_KeyExpiration;
+struct SyncActionValue_KeyExpirationDefaultTypeInternal;
+extern SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_;
+class SyncActionValue_LabelAssociationAction;
+struct SyncActionValue_LabelAssociationActionDefaultTypeInternal;
+extern SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_;
+class SyncActionValue_LabelEditAction;
+struct SyncActionValue_LabelEditActionDefaultTypeInternal;
+extern SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_;
+class SyncActionValue_LocaleSetting;
+struct SyncActionValue_LocaleSettingDefaultTypeInternal;
+extern SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_;
+class SyncActionValue_MarkChatAsReadAction;
+struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal;
+extern SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_;
+class SyncActionValue_MuteAction;
+struct SyncActionValue_MuteActionDefaultTypeInternal;
+extern SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_;
+class SyncActionValue_NuxAction;
+struct SyncActionValue_NuxActionDefaultTypeInternal;
+extern SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_;
+class SyncActionValue_PinAction;
+struct SyncActionValue_PinActionDefaultTypeInternal;
+extern SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_;
+class SyncActionValue_PrimaryFeature;
+struct SyncActionValue_PrimaryFeatureDefaultTypeInternal;
+extern SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_;
+class SyncActionValue_PrimaryVersionAction;
+struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal;
+extern SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_;
+class SyncActionValue_PushNameSetting;
+struct SyncActionValue_PushNameSettingDefaultTypeInternal;
+extern SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_;
+class SyncActionValue_QuickReplyAction;
+struct SyncActionValue_QuickReplyActionDefaultTypeInternal;
+extern SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_;
+class SyncActionValue_RecentEmojiWeightsAction;
+struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal;
+extern SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_;
+class SyncActionValue_SecurityNotificationSetting;
+struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal;
+extern SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_;
+class SyncActionValue_StarAction;
+struct SyncActionValue_StarActionDefaultTypeInternal;
+extern SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_;
+class SyncActionValue_StickerAction;
+struct SyncActionValue_StickerActionDefaultTypeInternal;
+extern SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_;
+class SyncActionValue_SubscriptionAction;
+struct SyncActionValue_SubscriptionActionDefaultTypeInternal;
+extern SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_;
+class SyncActionValue_SyncActionMessage;
+struct SyncActionValue_SyncActionMessageDefaultTypeInternal;
+extern SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_;
+class SyncActionValue_SyncActionMessageRange;
+struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal;
+extern SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_;
+class SyncActionValue_TimeFormatAction;
+struct SyncActionValue_TimeFormatActionDefaultTypeInternal;
+extern SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_;
+class SyncActionValue_UnarchiveChatsSetting;
+struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal;
+extern SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_;
+class SyncActionValue_UserStatusMuteAction;
+struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal;
+extern SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_;
+class SyncdIndex;
+struct SyncdIndexDefaultTypeInternal;
+extern SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_;
+class SyncdMutation;
+struct SyncdMutationDefaultTypeInternal;
+extern SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_;
+class SyncdMutations;
+struct SyncdMutationsDefaultTypeInternal;
+extern SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_;
+class SyncdPatch;
+struct SyncdPatchDefaultTypeInternal;
+extern SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_;
+class SyncdRecord;
+struct SyncdRecordDefaultTypeInternal;
+extern SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_;
+class SyncdSnapshot;
+struct SyncdSnapshotDefaultTypeInternal;
+extern SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_;
+class SyncdValue;
+struct SyncdValueDefaultTypeInternal;
+extern SyncdValueDefaultTypeInternal _SyncdValue_default_instance_;
+class SyncdVersion;
+struct SyncdVersionDefaultTypeInternal;
+extern SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_;
+class TemplateButton;
+struct TemplateButtonDefaultTypeInternal;
+extern TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_;
+class TemplateButton_CallButton;
+struct TemplateButton_CallButtonDefaultTypeInternal;
+extern TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_;
+class TemplateButton_QuickReplyButton;
+struct TemplateButton_QuickReplyButtonDefaultTypeInternal;
+extern TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_;
+class TemplateButton_URLButton;
+struct TemplateButton_URLButtonDefaultTypeInternal;
+extern TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_;
+class UserReceipt;
+struct UserReceiptDefaultTypeInternal;
+extern UserReceiptDefaultTypeInternal _UserReceipt_default_instance_;
+class VerifiedNameCertificate;
+struct VerifiedNameCertificateDefaultTypeInternal;
+extern VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_;
+class VerifiedNameCertificate_Details;
+struct VerifiedNameCertificate_DetailsDefaultTypeInternal;
+extern VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_;
+class WallpaperSettings;
+struct WallpaperSettingsDefaultTypeInternal;
+extern WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_;
+class WebFeatures;
+struct WebFeaturesDefaultTypeInternal;
+extern WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_;
+class WebMessageInfo;
+struct WebMessageInfoDefaultTypeInternal;
+extern WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_;
+class WebNotificationsInfo;
+struct WebNotificationsInfoDefaultTypeInternal;
+extern WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_;
+}  // namespace proto
+PROTOBUF_NAMESPACE_OPEN
+template<> ::proto::ADVDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVDeviceIdentity>(Arena*);
+template<> ::proto::ADVKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVKeyIndexList>(Arena*);
+template<> ::proto::ADVSignedDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentity>(Arena*);
+template<> ::proto::ADVSignedDeviceIdentityHMAC* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentityHMAC>(Arena*);
+template<> ::proto::ADVSignedKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVSignedKeyIndexList>(Arena*);
+template<> ::proto::ActionLink* Arena::CreateMaybeMessage<::proto::ActionLink>(Arena*);
+template<> ::proto::AutoDownloadSettings* Arena::CreateMaybeMessage<::proto::AutoDownloadSettings>(Arena*);
+template<> ::proto::BizAccountLinkInfo* Arena::CreateMaybeMessage<::proto::BizAccountLinkInfo>(Arena*);
+template<> ::proto::BizAccountPayload* Arena::CreateMaybeMessage<::proto::BizAccountPayload>(Arena*);
+template<> ::proto::BizIdentityInfo* Arena::CreateMaybeMessage<::proto::BizIdentityInfo>(Arena*);
+template<> ::proto::CertChain* Arena::CreateMaybeMessage<::proto::CertChain>(Arena*);
+template<> ::proto::CertChain_NoiseCertificate* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(Arena*);
+template<> ::proto::CertChain_NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate_Details>(Arena*);
+template<> ::proto::Chain* Arena::CreateMaybeMessage<::proto::Chain>(Arena*);
+template<> ::proto::ChainKey* Arena::CreateMaybeMessage<::proto::ChainKey>(Arena*);
+template<> ::proto::ClientPayload* Arena::CreateMaybeMessage<::proto::ClientPayload>(Arena*);
+template<> ::proto::ClientPayload_DNSSource* Arena::CreateMaybeMessage<::proto::ClientPayload_DNSSource>(Arena*);
+template<> ::proto::ClientPayload_DevicePairingRegistrationData* Arena::CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(Arena*);
+template<> ::proto::ClientPayload_UserAgent* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent>(Arena*);
+template<> ::proto::ClientPayload_UserAgent_AppVersion* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(Arena*);
+template<> ::proto::ClientPayload_WebInfo* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo>(Arena*);
+template<> ::proto::ClientPayload_WebInfo_WebdPayload* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(Arena*);
+template<> ::proto::ContextInfo* Arena::CreateMaybeMessage<::proto::ContextInfo>(Arena*);
+template<> ::proto::ContextInfo_AdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(Arena*);
+template<> ::proto::ContextInfo_ExternalAdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(Arena*);
+template<> ::proto::Conversation* Arena::CreateMaybeMessage<::proto::Conversation>(Arena*);
+template<> ::proto::DeviceListMetadata* Arena::CreateMaybeMessage<::proto::DeviceListMetadata>(Arena*);
+template<> ::proto::DeviceProps* Arena::CreateMaybeMessage<::proto::DeviceProps>(Arena*);
+template<> ::proto::DeviceProps_AppVersion* Arena::CreateMaybeMessage<::proto::DeviceProps_AppVersion>(Arena*);
+template<> ::proto::DisappearingMode* Arena::CreateMaybeMessage<::proto::DisappearingMode>(Arena*);
+template<> ::proto::EphemeralSetting* Arena::CreateMaybeMessage<::proto::EphemeralSetting>(Arena*);
+template<> ::proto::ExitCode* Arena::CreateMaybeMessage<::proto::ExitCode>(Arena*);
+template<> ::proto::ExternalBlobReference* Arena::CreateMaybeMessage<::proto::ExternalBlobReference>(Arena*);
+template<> ::proto::GlobalSettings* Arena::CreateMaybeMessage<::proto::GlobalSettings>(Arena*);
+template<> ::proto::GroupParticipant* Arena::CreateMaybeMessage<::proto::GroupParticipant>(Arena*);
+template<> ::proto::HandshakeMessage* Arena::CreateMaybeMessage<::proto::HandshakeMessage>(Arena*);
+template<> ::proto::HandshakeMessage_ClientFinish* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(Arena*);
+template<> ::proto::HandshakeMessage_ClientHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(Arena*);
+template<> ::proto::HandshakeMessage_ServerHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(Arena*);
+template<> ::proto::HistorySync* Arena::CreateMaybeMessage<::proto::HistorySync>(Arena*);
+template<> ::proto::HistorySyncMsg* Arena::CreateMaybeMessage<::proto::HistorySyncMsg>(Arena*);
+template<> ::proto::HydratedTemplateButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton>(Arena*);
+template<> ::proto::HydratedTemplateButton_HydratedCallButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedCallButton>(Arena*);
+template<> ::proto::HydratedTemplateButton_HydratedQuickReplyButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedQuickReplyButton>(Arena*);
+template<> ::proto::HydratedTemplateButton_HydratedURLButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedURLButton>(Arena*);
+template<> ::proto::IdentityKeyPairStructure* Arena::CreateMaybeMessage<::proto::IdentityKeyPairStructure>(Arena*);
+template<> ::proto::InteractiveAnnotation* Arena::CreateMaybeMessage<::proto::InteractiveAnnotation>(Arena*);
+template<> ::proto::KeepInChat* Arena::CreateMaybeMessage<::proto::KeepInChat>(Arena*);
+template<> ::proto::KeyId* Arena::CreateMaybeMessage<::proto::KeyId>(Arena*);
+template<> ::proto::LocalizedName* Arena::CreateMaybeMessage<::proto::LocalizedName>(Arena*);
+template<> ::proto::Location* Arena::CreateMaybeMessage<::proto::Location>(Arena*);
+template<> ::proto::MediaData* Arena::CreateMaybeMessage<::proto::MediaData>(Arena*);
+template<> ::proto::MediaRetryNotification* Arena::CreateMaybeMessage<::proto::MediaRetryNotification>(Arena*);
+template<> ::proto::Message* Arena::CreateMaybeMessage<::proto::Message>(Arena*);
+template<> ::proto::MessageContextInfo* Arena::CreateMaybeMessage<::proto::MessageContextInfo>(Arena*);
+template<> ::proto::MessageKey* Arena::CreateMaybeMessage<::proto::MessageKey>(Arena*);
+template<> ::proto::Message_AppStateFatalExceptionNotification* Arena::CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(Arena*);
+template<> ::proto::Message_AppStateSyncKey* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKey>(Arena*);
+template<> ::proto::Message_AppStateSyncKeyData* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(Arena*);
+template<> ::proto::Message_AppStateSyncKeyFingerprint* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(Arena*);
+template<> ::proto::Message_AppStateSyncKeyId* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(Arena*);
+template<> ::proto::Message_AppStateSyncKeyRequest* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(Arena*);
+template<> ::proto::Message_AppStateSyncKeyShare* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(Arena*);
+template<> ::proto::Message_AudioMessage* Arena::CreateMaybeMessage<::proto::Message_AudioMessage>(Arena*);
+template<> ::proto::Message_ButtonsMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage>(Arena*);
+template<> ::proto::Message_ButtonsMessage_Button* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button>(Arena*);
+template<> ::proto::Message_ButtonsMessage_Button_ButtonText* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(Arena*);
+template<> ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(Arena*);
+template<> ::proto::Message_ButtonsResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(Arena*);
+template<> ::proto::Message_Call* Arena::CreateMaybeMessage<::proto::Message_Call>(Arena*);
+template<> ::proto::Message_CancelPaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(Arena*);
+template<> ::proto::Message_Chat* Arena::CreateMaybeMessage<::proto::Message_Chat>(Arena*);
+template<> ::proto::Message_ContactMessage* Arena::CreateMaybeMessage<::proto::Message_ContactMessage>(Arena*);
+template<> ::proto::Message_ContactsArrayMessage* Arena::CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(Arena*);
+template<> ::proto::Message_DeclinePaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(Arena*);
+template<> ::proto::Message_DeviceSentMessage* Arena::CreateMaybeMessage<::proto::Message_DeviceSentMessage>(Arena*);
+template<> ::proto::Message_DocumentMessage* Arena::CreateMaybeMessage<::proto::Message_DocumentMessage>(Arena*);
+template<> ::proto::Message_ExtendedTextMessage* Arena::CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(Arena*);
+template<> ::proto::Message_FutureProofMessage* Arena::CreateMaybeMessage<::proto::Message_FutureProofMessage>(Arena*);
+template<> ::proto::Message_GroupInviteMessage* Arena::CreateMaybeMessage<::proto::Message_GroupInviteMessage>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(Arena*);
+template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(Arena*);
+template<> ::proto::Message_HistorySyncNotification* Arena::CreateMaybeMessage<::proto::Message_HistorySyncNotification>(Arena*);
+template<> ::proto::Message_ImageMessage* Arena::CreateMaybeMessage<::proto::Message_ImageMessage>(Arena*);
+template<> ::proto::Message_InitialSecurityNotificationSettingSync* Arena::CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(Arena*);
+template<> ::proto::Message_InteractiveMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage>(Arena*);
+template<> ::proto::Message_InteractiveMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(Arena*);
+template<> ::proto::Message_InteractiveMessage_CollectionMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_CollectionMessage>(Arena*);
+template<> ::proto::Message_InteractiveMessage_Footer* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(Arena*);
+template<> ::proto::Message_InteractiveMessage_Header* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(Arena*);
+template<> ::proto::Message_InteractiveMessage_NativeFlowMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage>(Arena*);
+template<> ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(Arena*);
+template<> ::proto::Message_InteractiveMessage_ShopMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_ShopMessage>(Arena*);
+template<> ::proto::Message_InteractiveResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(Arena*);
+template<> ::proto::Message_InteractiveResponseMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(Arena*);
+template<> ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage>(Arena*);
+template<> ::proto::Message_InvoiceMessage* Arena::CreateMaybeMessage<::proto::Message_InvoiceMessage>(Arena*);
+template<> ::proto::Message_KeepInChatMessage* Arena::CreateMaybeMessage<::proto::Message_KeepInChatMessage>(Arena*);
+template<> ::proto::Message_ListMessage* Arena::CreateMaybeMessage<::proto::Message_ListMessage>(Arena*);
+template<> ::proto::Message_ListMessage_Product* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Product>(Arena*);
+template<> ::proto::Message_ListMessage_ProductListHeaderImage* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(Arena*);
+template<> ::proto::Message_ListMessage_ProductListInfo* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(Arena*);
+template<> ::proto::Message_ListMessage_ProductSection* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductSection>(Arena*);
+template<> ::proto::Message_ListMessage_Row* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Row>(Arena*);
+template<> ::proto::Message_ListMessage_Section* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Section>(Arena*);
+template<> ::proto::Message_ListResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage>(Arena*);
+template<> ::proto::Message_ListResponseMessage_SingleSelectReply* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(Arena*);
+template<> ::proto::Message_LiveLocationMessage* Arena::CreateMaybeMessage<::proto::Message_LiveLocationMessage>(Arena*);
+template<> ::proto::Message_LocationMessage* Arena::CreateMaybeMessage<::proto::Message_LocationMessage>(Arena*);
+template<> ::proto::Message_OrderMessage* Arena::CreateMaybeMessage<::proto::Message_OrderMessage>(Arena*);
+template<> ::proto::Message_PaymentInviteMessage* Arena::CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(Arena*);
+template<> ::proto::Message_PollCreationMessage* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage>(Arena*);
+template<> ::proto::Message_PollCreationMessage_Option* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage_Option>(Arena*);
+template<> ::proto::Message_PollEncValue* Arena::CreateMaybeMessage<::proto::Message_PollEncValue>(Arena*);
+template<> ::proto::Message_PollUpdateMessage* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessage>(Arena*);
+template<> ::proto::Message_PollUpdateMessageMetadata* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(Arena*);
+template<> ::proto::Message_PollVoteMessage* Arena::CreateMaybeMessage<::proto::Message_PollVoteMessage>(Arena*);
+template<> ::proto::Message_ProductMessage* Arena::CreateMaybeMessage<::proto::Message_ProductMessage>(Arena*);
+template<> ::proto::Message_ProductMessage_CatalogSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(Arena*);
+template<> ::proto::Message_ProductMessage_ProductSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(Arena*);
+template<> ::proto::Message_ProtocolMessage* Arena::CreateMaybeMessage<::proto::Message_ProtocolMessage>(Arena*);
+template<> ::proto::Message_ReactionMessage* Arena::CreateMaybeMessage<::proto::Message_ReactionMessage>(Arena*);
+template<> ::proto::Message_RequestMediaUploadMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(Arena*);
+template<> ::proto::Message_RequestMediaUploadResponseMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(Arena*);
+template<> ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(Arena*);
+template<> ::proto::Message_RequestPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(Arena*);
+template<> ::proto::Message_RequestPhoneNumberMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(Arena*);
+template<> ::proto::Message_SendPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_SendPaymentMessage>(Arena*);
+template<> ::proto::Message_SenderKeyDistributionMessage* Arena::CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(Arena*);
+template<> ::proto::Message_StickerMessage* Arena::CreateMaybeMessage<::proto::Message_StickerMessage>(Arena*);
+template<> ::proto::Message_StickerSyncRMRMessage* Arena::CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(Arena*);
+template<> ::proto::Message_TemplateButtonReplyMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(Arena*);
+template<> ::proto::Message_TemplateMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage>(Arena*);
+template<> ::proto::Message_TemplateMessage_FourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_FourRowTemplate>(Arena*);
+template<> ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(Arena*);
+template<> ::proto::Message_VideoMessage* Arena::CreateMaybeMessage<::proto::Message_VideoMessage>(Arena*);
+template<> ::proto::Money* Arena::CreateMaybeMessage<::proto::Money>(Arena*);
+template<> ::proto::MsgOpaqueData* Arena::CreateMaybeMessage<::proto::MsgOpaqueData>(Arena*);
+template<> ::proto::MsgOpaqueData_PollOption* Arena::CreateMaybeMessage<::proto::MsgOpaqueData_PollOption>(Arena*);
+template<> ::proto::MsgRowOpaqueData* Arena::CreateMaybeMessage<::proto::MsgRowOpaqueData>(Arena*);
+template<> ::proto::NoiseCertificate* Arena::CreateMaybeMessage<::proto::NoiseCertificate>(Arena*);
+template<> ::proto::NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::NoiseCertificate_Details>(Arena*);
+template<> ::proto::NotificationMessageInfo* Arena::CreateMaybeMessage<::proto::NotificationMessageInfo>(Arena*);
+template<> ::proto::PastParticipant* Arena::CreateMaybeMessage<::proto::PastParticipant>(Arena*);
+template<> ::proto::PastParticipants* Arena::CreateMaybeMessage<::proto::PastParticipants>(Arena*);
+template<> ::proto::PaymentBackground* Arena::CreateMaybeMessage<::proto::PaymentBackground>(Arena*);
+template<> ::proto::PaymentBackground_MediaData* Arena::CreateMaybeMessage<::proto::PaymentBackground_MediaData>(Arena*);
+template<> ::proto::PaymentInfo* Arena::CreateMaybeMessage<::proto::PaymentInfo>(Arena*);
+template<> ::proto::PendingKeyExchange* Arena::CreateMaybeMessage<::proto::PendingKeyExchange>(Arena*);
+template<> ::proto::PendingPreKey* Arena::CreateMaybeMessage<::proto::PendingPreKey>(Arena*);
+template<> ::proto::PhotoChange* Arena::CreateMaybeMessage<::proto::PhotoChange>(Arena*);
+template<> ::proto::Point* Arena::CreateMaybeMessage<::proto::Point>(Arena*);
+template<> ::proto::PollAdditionalMetadata* Arena::CreateMaybeMessage<::proto::PollAdditionalMetadata>(Arena*);
+template<> ::proto::PollEncValue* Arena::CreateMaybeMessage<::proto::PollEncValue>(Arena*);
+template<> ::proto::PollUpdate* Arena::CreateMaybeMessage<::proto::PollUpdate>(Arena*);
+template<> ::proto::PreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::PreKeyRecordStructure>(Arena*);
+template<> ::proto::Pushname* Arena::CreateMaybeMessage<::proto::Pushname>(Arena*);
+template<> ::proto::Reaction* Arena::CreateMaybeMessage<::proto::Reaction>(Arena*);
+template<> ::proto::RecentEmojiWeight* Arena::CreateMaybeMessage<::proto::RecentEmojiWeight>(Arena*);
+template<> ::proto::RecordStructure* Arena::CreateMaybeMessage<::proto::RecordStructure>(Arena*);
+template<> ::proto::SenderChainKey* Arena::CreateMaybeMessage<::proto::SenderChainKey>(Arena*);
+template<> ::proto::SenderKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SenderKeyRecordStructure>(Arena*);
+template<> ::proto::SenderKeyStateStructure* Arena::CreateMaybeMessage<::proto::SenderKeyStateStructure>(Arena*);
+template<> ::proto::SenderMessageKey* Arena::CreateMaybeMessage<::proto::SenderMessageKey>(Arena*);
+template<> ::proto::SenderSigningKey* Arena::CreateMaybeMessage<::proto::SenderSigningKey>(Arena*);
+template<> ::proto::ServerErrorReceipt* Arena::CreateMaybeMessage<::proto::ServerErrorReceipt>(Arena*);
+template<> ::proto::SessionStructure* Arena::CreateMaybeMessage<::proto::SessionStructure>(Arena*);
+template<> ::proto::SignedPreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SignedPreKeyRecordStructure>(Arena*);
+template<> ::proto::StatusPSA* Arena::CreateMaybeMessage<::proto::StatusPSA>(Arena*);
+template<> ::proto::StickerMetadata* Arena::CreateMaybeMessage<::proto::StickerMetadata>(Arena*);
+template<> ::proto::SyncActionData* Arena::CreateMaybeMessage<::proto::SyncActionData>(Arena*);
+template<> ::proto::SyncActionValue* Arena::CreateMaybeMessage<::proto::SyncActionValue>(Arena*);
+template<> ::proto::SyncActionValue_AgentAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(Arena*);
+template<> ::proto::SyncActionValue_AndroidUnsupportedActions* Arena::CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(Arena*);
+template<> ::proto::SyncActionValue_ArchiveChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(Arena*);
+template<> ::proto::SyncActionValue_ClearChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(Arena*);
+template<> ::proto::SyncActionValue_ContactAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(Arena*);
+template<> ::proto::SyncActionValue_DeleteChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(Arena*);
+template<> ::proto::SyncActionValue_DeleteMessageForMeAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(Arena*);
+template<> ::proto::SyncActionValue_KeyExpiration* Arena::CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(Arena*);
+template<> ::proto::SyncActionValue_LabelAssociationAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(Arena*);
+template<> ::proto::SyncActionValue_LabelEditAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(Arena*);
+template<> ::proto::SyncActionValue_LocaleSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(Arena*);
+template<> ::proto::SyncActionValue_MarkChatAsReadAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(Arena*);
+template<> ::proto::SyncActionValue_MuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(Arena*);
+template<> ::proto::SyncActionValue_NuxAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(Arena*);
+template<> ::proto::SyncActionValue_PinAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PinAction>(Arena*);
+template<> ::proto::SyncActionValue_PrimaryFeature* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(Arena*);
+template<> ::proto::SyncActionValue_PrimaryVersionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(Arena*);
+template<> ::proto::SyncActionValue_PushNameSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(Arena*);
+template<> ::proto::SyncActionValue_QuickReplyAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(Arena*);
+template<> ::proto::SyncActionValue_RecentEmojiWeightsAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(Arena*);
+template<> ::proto::SyncActionValue_SecurityNotificationSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(Arena*);
+template<> ::proto::SyncActionValue_StarAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StarAction>(Arena*);
+template<> ::proto::SyncActionValue_StickerAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(Arena*);
+template<> ::proto::SyncActionValue_SubscriptionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(Arena*);
+template<> ::proto::SyncActionValue_SyncActionMessage* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessage>(Arena*);
+template<> ::proto::SyncActionValue_SyncActionMessageRange* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(Arena*);
+template<> ::proto::SyncActionValue_TimeFormatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(Arena*);
+template<> ::proto::SyncActionValue_UnarchiveChatsSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(Arena*);
+template<> ::proto::SyncActionValue_UserStatusMuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(Arena*);
+template<> ::proto::SyncdIndex* Arena::CreateMaybeMessage<::proto::SyncdIndex>(Arena*);
+template<> ::proto::SyncdMutation* Arena::CreateMaybeMessage<::proto::SyncdMutation>(Arena*);
+template<> ::proto::SyncdMutations* Arena::CreateMaybeMessage<::proto::SyncdMutations>(Arena*);
+template<> ::proto::SyncdPatch* Arena::CreateMaybeMessage<::proto::SyncdPatch>(Arena*);
+template<> ::proto::SyncdRecord* Arena::CreateMaybeMessage<::proto::SyncdRecord>(Arena*);
+template<> ::proto::SyncdSnapshot* Arena::CreateMaybeMessage<::proto::SyncdSnapshot>(Arena*);
+template<> ::proto::SyncdValue* Arena::CreateMaybeMessage<::proto::SyncdValue>(Arena*);
+template<> ::proto::SyncdVersion* Arena::CreateMaybeMessage<::proto::SyncdVersion>(Arena*);
+template<> ::proto::TemplateButton* Arena::CreateMaybeMessage<::proto::TemplateButton>(Arena*);
+template<> ::proto::TemplateButton_CallButton* Arena::CreateMaybeMessage<::proto::TemplateButton_CallButton>(Arena*);
+template<> ::proto::TemplateButton_QuickReplyButton* Arena::CreateMaybeMessage<::proto::TemplateButton_QuickReplyButton>(Arena*);
+template<> ::proto::TemplateButton_URLButton* Arena::CreateMaybeMessage<::proto::TemplateButton_URLButton>(Arena*);
+template<> ::proto::UserReceipt* Arena::CreateMaybeMessage<::proto::UserReceipt>(Arena*);
+template<> ::proto::VerifiedNameCertificate* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate>(Arena*);
+template<> ::proto::VerifiedNameCertificate_Details* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate_Details>(Arena*);
+template<> ::proto::WallpaperSettings* Arena::CreateMaybeMessage<::proto::WallpaperSettings>(Arena*);
+template<> ::proto::WebFeatures* Arena::CreateMaybeMessage<::proto::WebFeatures>(Arena*);
+template<> ::proto::WebMessageInfo* Arena::CreateMaybeMessage<::proto::WebMessageInfo>(Arena*);
+template<> ::proto::WebNotificationsInfo* Arena::CreateMaybeMessage<::proto::WebNotificationsInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace proto {
+
+enum BizAccountLinkInfo_AccountType : int {
+  BizAccountLinkInfo_AccountType_ENTERPRISE = 0
+};
+bool BizAccountLinkInfo_AccountType_IsValid(int value);
+constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MIN = BizAccountLinkInfo_AccountType_ENTERPRISE;
+constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MAX = BizAccountLinkInfo_AccountType_ENTERPRISE;
+constexpr int BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE = BizAccountLinkInfo_AccountType_AccountType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor();
+template<typename T>
+inline const std::string& BizAccountLinkInfo_AccountType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, BizAccountLinkInfo_AccountType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function BizAccountLinkInfo_AccountType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    BizAccountLinkInfo_AccountType_descriptor(), enum_t_value);
+}
+inline bool BizAccountLinkInfo_AccountType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_AccountType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizAccountLinkInfo_AccountType>(
+    BizAccountLinkInfo_AccountType_descriptor(), name, value);
+}
+enum BizAccountLinkInfo_HostStorageType : int {
+  BizAccountLinkInfo_HostStorageType_ON_PREMISE = 0,
+  BizAccountLinkInfo_HostStorageType_FACEBOOK = 1
+};
+bool BizAccountLinkInfo_HostStorageType_IsValid(int value);
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MIN = BizAccountLinkInfo_HostStorageType_ON_PREMISE;
+constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MAX = BizAccountLinkInfo_HostStorageType_FACEBOOK;
+constexpr int BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizAccountLinkInfo_HostStorageType_HostStorageType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor();
+template<typename T>
+inline const std::string& BizAccountLinkInfo_HostStorageType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, BizAccountLinkInfo_HostStorageType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function BizAccountLinkInfo_HostStorageType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    BizAccountLinkInfo_HostStorageType_descriptor(), enum_t_value);
+}
+inline bool BizAccountLinkInfo_HostStorageType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_HostStorageType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizAccountLinkInfo_HostStorageType>(
+    BizAccountLinkInfo_HostStorageType_descriptor(), name, value);
+}
+enum BizIdentityInfo_ActualActorsType : int {
+  BizIdentityInfo_ActualActorsType_SELF = 0,
+  BizIdentityInfo_ActualActorsType_BSP = 1
+};
+bool BizIdentityInfo_ActualActorsType_IsValid(int value);
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MIN = BizIdentityInfo_ActualActorsType_SELF;
+constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MAX = BizIdentityInfo_ActualActorsType_BSP;
+constexpr int BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE = BizIdentityInfo_ActualActorsType_ActualActorsType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor();
+template<typename T>
+inline const std::string& BizIdentityInfo_ActualActorsType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, BizIdentityInfo_ActualActorsType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function BizIdentityInfo_ActualActorsType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    BizIdentityInfo_ActualActorsType_descriptor(), enum_t_value);
+}
+inline bool BizIdentityInfo_ActualActorsType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_ActualActorsType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_ActualActorsType>(
+    BizIdentityInfo_ActualActorsType_descriptor(), name, value);
+}
+enum BizIdentityInfo_HostStorageType : int {
+  BizIdentityInfo_HostStorageType_ON_PREMISE = 0,
+  BizIdentityInfo_HostStorageType_FACEBOOK = 1
+};
+bool BizIdentityInfo_HostStorageType_IsValid(int value);
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MIN = BizIdentityInfo_HostStorageType_ON_PREMISE;
+constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MAX = BizIdentityInfo_HostStorageType_FACEBOOK;
+constexpr int BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizIdentityInfo_HostStorageType_HostStorageType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor();
+template<typename T>
+inline const std::string& BizIdentityInfo_HostStorageType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, BizIdentityInfo_HostStorageType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function BizIdentityInfo_HostStorageType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    BizIdentityInfo_HostStorageType_descriptor(), enum_t_value);
+}
+inline bool BizIdentityInfo_HostStorageType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_HostStorageType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_HostStorageType>(
+    BizIdentityInfo_HostStorageType_descriptor(), name, value);
+}
+enum BizIdentityInfo_VerifiedLevelValue : int {
+  BizIdentityInfo_VerifiedLevelValue_UNKNOWN = 0,
+  BizIdentityInfo_VerifiedLevelValue_LOW = 1,
+  BizIdentityInfo_VerifiedLevelValue_HIGH = 2
+};
+bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value);
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN = BizIdentityInfo_VerifiedLevelValue_UNKNOWN;
+constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX = BizIdentityInfo_VerifiedLevelValue_HIGH;
+constexpr int BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE = BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor();
+template<typename T>
+inline const std::string& BizIdentityInfo_VerifiedLevelValue_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, BizIdentityInfo_VerifiedLevelValue>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function BizIdentityInfo_VerifiedLevelValue_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    BizIdentityInfo_VerifiedLevelValue_descriptor(), enum_t_value);
+}
+inline bool BizIdentityInfo_VerifiedLevelValue_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_VerifiedLevelValue* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_VerifiedLevelValue>(
+    BizIdentityInfo_VerifiedLevelValue_descriptor(), name, value);
+}
+enum ClientPayload_DNSSource_DNSResolutionMethod : int {
+  ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM = 0,
+  ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE = 1,
+  ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED = 2,
+  ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE = 3,
+  ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK = 4
+};
+bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value);
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN = ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM;
+constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX = ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK;
+constexpr int ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE = ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_DNSSource_DNSResolutionMethod_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_DNSSource_DNSResolutionMethod>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_DNSSource_DNSResolutionMethod_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_DNSSource_DNSResolutionMethod_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_DNSSource_DNSResolutionMethod* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_DNSSource_DNSResolutionMethod>(
+    ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), name, value);
+}
+enum ClientPayload_UserAgent_Platform : int {
+  ClientPayload_UserAgent_Platform_ANDROID = 0,
+  ClientPayload_UserAgent_Platform_IOS = 1,
+  ClientPayload_UserAgent_Platform_WINDOWS_PHONE = 2,
+  ClientPayload_UserAgent_Platform_BLACKBERRY = 3,
+  ClientPayload_UserAgent_Platform_BLACKBERRYX = 4,
+  ClientPayload_UserAgent_Platform_S40 = 5,
+  ClientPayload_UserAgent_Platform_S60 = 6,
+  ClientPayload_UserAgent_Platform_PYTHON_CLIENT = 7,
+  ClientPayload_UserAgent_Platform_TIZEN = 8,
+  ClientPayload_UserAgent_Platform_ENTERPRISE = 9,
+  ClientPayload_UserAgent_Platform_SMB_ANDROID = 10,
+  ClientPayload_UserAgent_Platform_KAIOS = 11,
+  ClientPayload_UserAgent_Platform_SMB_IOS = 12,
+  ClientPayload_UserAgent_Platform_WINDOWS = 13,
+  ClientPayload_UserAgent_Platform_WEB = 14,
+  ClientPayload_UserAgent_Platform_PORTAL = 15,
+  ClientPayload_UserAgent_Platform_GREEN_ANDROID = 16,
+  ClientPayload_UserAgent_Platform_GREEN_IPHONE = 17,
+  ClientPayload_UserAgent_Platform_BLUE_ANDROID = 18,
+  ClientPayload_UserAgent_Platform_BLUE_IPHONE = 19,
+  ClientPayload_UserAgent_Platform_FBLITE_ANDROID = 20,
+  ClientPayload_UserAgent_Platform_MLITE_ANDROID = 21,
+  ClientPayload_UserAgent_Platform_IGLITE_ANDROID = 22,
+  ClientPayload_UserAgent_Platform_PAGE = 23,
+  ClientPayload_UserAgent_Platform_MACOS = 24,
+  ClientPayload_UserAgent_Platform_OCULUS_MSG = 25,
+  ClientPayload_UserAgent_Platform_OCULUS_CALL = 26,
+  ClientPayload_UserAgent_Platform_MILAN = 27,
+  ClientPayload_UserAgent_Platform_CAPI = 28
+};
+bool ClientPayload_UserAgent_Platform_IsValid(int value);
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MIN = ClientPayload_UserAgent_Platform_ANDROID;
+constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MAX = ClientPayload_UserAgent_Platform_CAPI;
+constexpr int ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE = ClientPayload_UserAgent_Platform_Platform_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_UserAgent_Platform_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_UserAgent_Platform>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_UserAgent_Platform_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_UserAgent_Platform_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_UserAgent_Platform_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_Platform* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_UserAgent_Platform>(
+    ClientPayload_UserAgent_Platform_descriptor(), name, value);
+}
+enum ClientPayload_UserAgent_ReleaseChannel : int {
+  ClientPayload_UserAgent_ReleaseChannel_RELEASE = 0,
+  ClientPayload_UserAgent_ReleaseChannel_BETA = 1,
+  ClientPayload_UserAgent_ReleaseChannel_ALPHA = 2,
+  ClientPayload_UserAgent_ReleaseChannel_DEBUG = 3
+};
+bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value);
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN = ClientPayload_UserAgent_ReleaseChannel_RELEASE;
+constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX = ClientPayload_UserAgent_ReleaseChannel_DEBUG;
+constexpr int ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE = ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_UserAgent_ReleaseChannel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_UserAgent_ReleaseChannel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_UserAgent_ReleaseChannel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_UserAgent_ReleaseChannel_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_UserAgent_ReleaseChannel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_ReleaseChannel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_UserAgent_ReleaseChannel>(
+    ClientPayload_UserAgent_ReleaseChannel_descriptor(), name, value);
+}
+enum ClientPayload_WebInfo_WebSubPlatform : int {
+  ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER = 0,
+  ClientPayload_WebInfo_WebSubPlatform_APP_STORE = 1,
+  ClientPayload_WebInfo_WebSubPlatform_WIN_STORE = 2,
+  ClientPayload_WebInfo_WebSubPlatform_DARWIN = 3,
+  ClientPayload_WebInfo_WebSubPlatform_WINDA = 4
+};
+bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value);
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN = ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER;
+constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX = ClientPayload_WebInfo_WebSubPlatform_WINDA;
+constexpr int ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE = ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_WebInfo_WebSubPlatform_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_WebInfo_WebSubPlatform>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_WebInfo_WebSubPlatform_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_WebInfo_WebSubPlatform_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_WebInfo_WebSubPlatform_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_WebInfo_WebSubPlatform* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_WebInfo_WebSubPlatform>(
+    ClientPayload_WebInfo_WebSubPlatform_descriptor(), name, value);
+}
+enum ClientPayload_ConnectReason : int {
+  ClientPayload_ConnectReason_PUSH = 0,
+  ClientPayload_ConnectReason_USER_ACTIVATED = 1,
+  ClientPayload_ConnectReason_SCHEDULED = 2,
+  ClientPayload_ConnectReason_ERROR_RECONNECT = 3,
+  ClientPayload_ConnectReason_NETWORK_SWITCH = 4,
+  ClientPayload_ConnectReason_PING_RECONNECT = 5
+};
+bool ClientPayload_ConnectReason_IsValid(int value);
+constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MIN = ClientPayload_ConnectReason_PUSH;
+constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MAX = ClientPayload_ConnectReason_PING_RECONNECT;
+constexpr int ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE = ClientPayload_ConnectReason_ConnectReason_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_ConnectReason_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_ConnectReason>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_ConnectReason_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_ConnectReason_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_ConnectReason_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectReason* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_ConnectReason>(
+    ClientPayload_ConnectReason_descriptor(), name, value);
+}
+enum ClientPayload_ConnectType : int {
+  ClientPayload_ConnectType_CELLULAR_UNKNOWN = 0,
+  ClientPayload_ConnectType_WIFI_UNKNOWN = 1,
+  ClientPayload_ConnectType_CELLULAR_EDGE = 100,
+  ClientPayload_ConnectType_CELLULAR_IDEN = 101,
+  ClientPayload_ConnectType_CELLULAR_UMTS = 102,
+  ClientPayload_ConnectType_CELLULAR_EVDO = 103,
+  ClientPayload_ConnectType_CELLULAR_GPRS = 104,
+  ClientPayload_ConnectType_CELLULAR_HSDPA = 105,
+  ClientPayload_ConnectType_CELLULAR_HSUPA = 106,
+  ClientPayload_ConnectType_CELLULAR_HSPA = 107,
+  ClientPayload_ConnectType_CELLULAR_CDMA = 108,
+  ClientPayload_ConnectType_CELLULAR_1XRTT = 109,
+  ClientPayload_ConnectType_CELLULAR_EHRPD = 110,
+  ClientPayload_ConnectType_CELLULAR_LTE = 111,
+  ClientPayload_ConnectType_CELLULAR_HSPAP = 112
+};
+bool ClientPayload_ConnectType_IsValid(int value);
+constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MIN = ClientPayload_ConnectType_CELLULAR_UNKNOWN;
+constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MAX = ClientPayload_ConnectType_CELLULAR_HSPAP;
+constexpr int ClientPayload_ConnectType_ConnectType_ARRAYSIZE = ClientPayload_ConnectType_ConnectType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_ConnectType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_ConnectType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_ConnectType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_ConnectType_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_ConnectType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_ConnectType>(
+    ClientPayload_ConnectType_descriptor(), name, value);
+}
+enum ClientPayload_IOSAppExtension : int {
+  ClientPayload_IOSAppExtension_SHARE_EXTENSION = 0,
+  ClientPayload_IOSAppExtension_SERVICE_EXTENSION = 1,
+  ClientPayload_IOSAppExtension_INTENTS_EXTENSION = 2
+};
+bool ClientPayload_IOSAppExtension_IsValid(int value);
+constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MIN = ClientPayload_IOSAppExtension_SHARE_EXTENSION;
+constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MAX = ClientPayload_IOSAppExtension_INTENTS_EXTENSION;
+constexpr int ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE = ClientPayload_IOSAppExtension_IOSAppExtension_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_IOSAppExtension_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_IOSAppExtension>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_IOSAppExtension_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_IOSAppExtension_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_IOSAppExtension_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_IOSAppExtension* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_IOSAppExtension>(
+    ClientPayload_IOSAppExtension_descriptor(), name, value);
+}
+enum ClientPayload_Product : int {
+  ClientPayload_Product_WHATSAPP = 0,
+  ClientPayload_Product_MESSENGER = 1
+};
+bool ClientPayload_Product_IsValid(int value);
+constexpr ClientPayload_Product ClientPayload_Product_Product_MIN = ClientPayload_Product_WHATSAPP;
+constexpr ClientPayload_Product ClientPayload_Product_Product_MAX = ClientPayload_Product_MESSENGER;
+constexpr int ClientPayload_Product_Product_ARRAYSIZE = ClientPayload_Product_Product_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor();
+template<typename T>
+inline const std::string& ClientPayload_Product_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientPayload_Product>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientPayload_Product_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientPayload_Product_descriptor(), enum_t_value);
+}
+inline bool ClientPayload_Product_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_Product* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_Product>(
+    ClientPayload_Product_descriptor(), name, value);
+}
+enum ContextInfo_AdReplyInfo_MediaType : int {
+  ContextInfo_AdReplyInfo_MediaType_NONE = 0,
+  ContextInfo_AdReplyInfo_MediaType_IMAGE = 1,
+  ContextInfo_AdReplyInfo_MediaType_VIDEO = 2
+};
+bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value);
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MIN = ContextInfo_AdReplyInfo_MediaType_NONE;
+constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MAX = ContextInfo_AdReplyInfo_MediaType_VIDEO;
+constexpr int ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_AdReplyInfo_MediaType_MediaType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor();
+template<typename T>
+inline const std::string& ContextInfo_AdReplyInfo_MediaType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ContextInfo_AdReplyInfo_MediaType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ContextInfo_AdReplyInfo_MediaType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ContextInfo_AdReplyInfo_MediaType_descriptor(), enum_t_value);
+}
+inline bool ContextInfo_AdReplyInfo_MediaType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_AdReplyInfo_MediaType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ContextInfo_AdReplyInfo_MediaType>(
+    ContextInfo_AdReplyInfo_MediaType_descriptor(), name, value);
+}
+enum ContextInfo_ExternalAdReplyInfo_MediaType : int {
+  ContextInfo_ExternalAdReplyInfo_MediaType_NONE = 0,
+  ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE = 1,
+  ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO = 2
+};
+bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value);
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN = ContextInfo_ExternalAdReplyInfo_MediaType_NONE;
+constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX = ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO;
+constexpr int ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
+template<typename T>
+inline const std::string& ContextInfo_ExternalAdReplyInfo_MediaType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ContextInfo_ExternalAdReplyInfo_MediaType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ContextInfo_ExternalAdReplyInfo_MediaType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), enum_t_value);
+}
+inline bool ContextInfo_ExternalAdReplyInfo_MediaType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_ExternalAdReplyInfo_MediaType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ContextInfo_ExternalAdReplyInfo_MediaType>(
+    ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), name, value);
+}
+enum Conversation_EndOfHistoryTransferType : int {
+  Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0,
+  Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1
+};
+bool Conversation_EndOfHistoryTransferType_IsValid(int value);
+constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN = Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY;
+constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX = Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY;
+constexpr int Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE = Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor();
+template<typename T>
+inline const std::string& Conversation_EndOfHistoryTransferType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Conversation_EndOfHistoryTransferType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Conversation_EndOfHistoryTransferType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Conversation_EndOfHistoryTransferType_descriptor(), enum_t_value);
+}
+inline bool Conversation_EndOfHistoryTransferType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Conversation_EndOfHistoryTransferType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Conversation_EndOfHistoryTransferType>(
+    Conversation_EndOfHistoryTransferType_descriptor(), name, value);
+}
+enum DeviceProps_PlatformType : int {
+  DeviceProps_PlatformType_UNKNOWN = 0,
+  DeviceProps_PlatformType_CHROME = 1,
+  DeviceProps_PlatformType_FIREFOX = 2,
+  DeviceProps_PlatformType_IE = 3,
+  DeviceProps_PlatformType_OPERA = 4,
+  DeviceProps_PlatformType_SAFARI = 5,
+  DeviceProps_PlatformType_EDGE = 6,
+  DeviceProps_PlatformType_DESKTOP = 7,
+  DeviceProps_PlatformType_IPAD = 8,
+  DeviceProps_PlatformType_ANDROID_TABLET = 9,
+  DeviceProps_PlatformType_OHANA = 10,
+  DeviceProps_PlatformType_ALOHA = 11,
+  DeviceProps_PlatformType_CATALINA = 12,
+  DeviceProps_PlatformType_TCL_TV = 13
+};
+bool DeviceProps_PlatformType_IsValid(int value);
+constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MIN = DeviceProps_PlatformType_UNKNOWN;
+constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MAX = DeviceProps_PlatformType_TCL_TV;
+constexpr int DeviceProps_PlatformType_PlatformType_ARRAYSIZE = DeviceProps_PlatformType_PlatformType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor();
+template<typename T>
+inline const std::string& DeviceProps_PlatformType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceProps_PlatformType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceProps_PlatformType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceProps_PlatformType_descriptor(), enum_t_value);
+}
+inline bool DeviceProps_PlatformType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceProps_PlatformType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceProps_PlatformType>(
+    DeviceProps_PlatformType_descriptor(), name, value);
+}
+enum DisappearingMode_Initiator : int {
+  DisappearingMode_Initiator_CHANGED_IN_CHAT = 0,
+  DisappearingMode_Initiator_INITIATED_BY_ME = 1,
+  DisappearingMode_Initiator_INITIATED_BY_OTHER = 2
+};
+bool DisappearingMode_Initiator_IsValid(int value);
+constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MIN = DisappearingMode_Initiator_CHANGED_IN_CHAT;
+constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MAX = DisappearingMode_Initiator_INITIATED_BY_OTHER;
+constexpr int DisappearingMode_Initiator_Initiator_ARRAYSIZE = DisappearingMode_Initiator_Initiator_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor();
+template<typename T>
+inline const std::string& DisappearingMode_Initiator_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DisappearingMode_Initiator>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DisappearingMode_Initiator_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DisappearingMode_Initiator_descriptor(), enum_t_value);
+}
+inline bool DisappearingMode_Initiator_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisappearingMode_Initiator* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DisappearingMode_Initiator>(
+    DisappearingMode_Initiator_descriptor(), name, value);
+}
+enum GroupParticipant_Rank : int {
+  GroupParticipant_Rank_REGULAR = 0,
+  GroupParticipant_Rank_ADMIN = 1,
+  GroupParticipant_Rank_SUPERADMIN = 2
+};
+bool GroupParticipant_Rank_IsValid(int value);
+constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MIN = GroupParticipant_Rank_REGULAR;
+constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MAX = GroupParticipant_Rank_SUPERADMIN;
+constexpr int GroupParticipant_Rank_Rank_ARRAYSIZE = GroupParticipant_Rank_Rank_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor();
+template<typename T>
+inline const std::string& GroupParticipant_Rank_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, GroupParticipant_Rank>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function GroupParticipant_Rank_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    GroupParticipant_Rank_descriptor(), enum_t_value);
+}
+inline bool GroupParticipant_Rank_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupParticipant_Rank* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GroupParticipant_Rank>(
+    GroupParticipant_Rank_descriptor(), name, value);
+}
+enum HistorySync_HistorySyncType : int {
+  HistorySync_HistorySyncType_INITIAL_BOOTSTRAP = 0,
+  HistorySync_HistorySyncType_INITIAL_STATUS_V3 = 1,
+  HistorySync_HistorySyncType_FULL = 2,
+  HistorySync_HistorySyncType_RECENT = 3,
+  HistorySync_HistorySyncType_PUSH_NAME = 4,
+  HistorySync_HistorySyncType_UNBLOCKING_DATA = 5
+};
+bool HistorySync_HistorySyncType_IsValid(int value);
+constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MIN = HistorySync_HistorySyncType_INITIAL_BOOTSTRAP;
+constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MAX = HistorySync_HistorySyncType_UNBLOCKING_DATA;
+constexpr int HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE = HistorySync_HistorySyncType_HistorySyncType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor();
+template<typename T>
+inline const std::string& HistorySync_HistorySyncType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HistorySync_HistorySyncType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HistorySync_HistorySyncType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HistorySync_HistorySyncType_descriptor(), enum_t_value);
+}
+inline bool HistorySync_HistorySyncType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HistorySync_HistorySyncType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HistorySync_HistorySyncType>(
+    HistorySync_HistorySyncType_descriptor(), name, value);
+}
+enum MediaRetryNotification_ResultType : int {
+  MediaRetryNotification_ResultType_GENERAL_ERROR = 0,
+  MediaRetryNotification_ResultType_SUCCESS = 1,
+  MediaRetryNotification_ResultType_NOT_FOUND = 2,
+  MediaRetryNotification_ResultType_DECRYPTION_ERROR = 3
+};
+bool MediaRetryNotification_ResultType_IsValid(int value);
+constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MIN = MediaRetryNotification_ResultType_GENERAL_ERROR;
+constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MAX = MediaRetryNotification_ResultType_DECRYPTION_ERROR;
+constexpr int MediaRetryNotification_ResultType_ResultType_ARRAYSIZE = MediaRetryNotification_ResultType_ResultType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor();
+template<typename T>
+inline const std::string& MediaRetryNotification_ResultType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MediaRetryNotification_ResultType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MediaRetryNotification_ResultType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    MediaRetryNotification_ResultType_descriptor(), enum_t_value);
+}
+inline bool MediaRetryNotification_ResultType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaRetryNotification_ResultType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MediaRetryNotification_ResultType>(
+    MediaRetryNotification_ResultType_descriptor(), name, value);
+}
+enum Message_ButtonsMessage_Button_Type : int {
+  Message_ButtonsMessage_Button_Type_UNKNOWN = 0,
+  Message_ButtonsMessage_Button_Type_RESPONSE = 1,
+  Message_ButtonsMessage_Button_Type_NATIVE_FLOW = 2
+};
+bool Message_ButtonsMessage_Button_Type_IsValid(int value);
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MIN = Message_ButtonsMessage_Button_Type_UNKNOWN;
+constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MAX = Message_ButtonsMessage_Button_Type_NATIVE_FLOW;
+constexpr int Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE = Message_ButtonsMessage_Button_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor();
+template<typename T>
+inline const std::string& Message_ButtonsMessage_Button_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ButtonsMessage_Button_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ButtonsMessage_Button_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ButtonsMessage_Button_Type_descriptor(), enum_t_value);
+}
+inline bool Message_ButtonsMessage_Button_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_Button_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsMessage_Button_Type>(
+    Message_ButtonsMessage_Button_Type_descriptor(), name, value);
+}
+enum Message_ButtonsMessage_HeaderType : int {
+  Message_ButtonsMessage_HeaderType_UNKNOWN = 0,
+  Message_ButtonsMessage_HeaderType_EMPTY = 1,
+  Message_ButtonsMessage_HeaderType_TEXT = 2,
+  Message_ButtonsMessage_HeaderType_DOCUMENT = 3,
+  Message_ButtonsMessage_HeaderType_IMAGE = 4,
+  Message_ButtonsMessage_HeaderType_VIDEO = 5,
+  Message_ButtonsMessage_HeaderType_LOCATION = 6
+};
+bool Message_ButtonsMessage_HeaderType_IsValid(int value);
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MIN = Message_ButtonsMessage_HeaderType_UNKNOWN;
+constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MAX = Message_ButtonsMessage_HeaderType_LOCATION;
+constexpr int Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE = Message_ButtonsMessage_HeaderType_HeaderType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor();
+template<typename T>
+inline const std::string& Message_ButtonsMessage_HeaderType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ButtonsMessage_HeaderType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ButtonsMessage_HeaderType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ButtonsMessage_HeaderType_descriptor(), enum_t_value);
+}
+inline bool Message_ButtonsMessage_HeaderType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_HeaderType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsMessage_HeaderType>(
+    Message_ButtonsMessage_HeaderType_descriptor(), name, value);
+}
+enum Message_ButtonsResponseMessage_Type : int {
+  Message_ButtonsResponseMessage_Type_UNKNOWN = 0,
+  Message_ButtonsResponseMessage_Type_DISPLAY_TEXT = 1
+};
+bool Message_ButtonsResponseMessage_Type_IsValid(int value);
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MIN = Message_ButtonsResponseMessage_Type_UNKNOWN;
+constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MAX = Message_ButtonsResponseMessage_Type_DISPLAY_TEXT;
+constexpr int Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE = Message_ButtonsResponseMessage_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor();
+template<typename T>
+inline const std::string& Message_ButtonsResponseMessage_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ButtonsResponseMessage_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ButtonsResponseMessage_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ButtonsResponseMessage_Type_descriptor(), enum_t_value);
+}
+inline bool Message_ButtonsResponseMessage_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsResponseMessage_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsResponseMessage_Type>(
+    Message_ButtonsResponseMessage_Type_descriptor(), name, value);
+}
+enum Message_ExtendedTextMessage_FontType : int {
+  Message_ExtendedTextMessage_FontType_SANS_SERIF = 0,
+  Message_ExtendedTextMessage_FontType_SERIF = 1,
+  Message_ExtendedTextMessage_FontType_NORICAN_REGULAR = 2,
+  Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE = 3,
+  Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR = 4,
+  Message_ExtendedTextMessage_FontType_OSWALD_HEAVY = 5
+};
+bool Message_ExtendedTextMessage_FontType_IsValid(int value);
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MIN = Message_ExtendedTextMessage_FontType_SANS_SERIF;
+constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MAX = Message_ExtendedTextMessage_FontType_OSWALD_HEAVY;
+constexpr int Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE = Message_ExtendedTextMessage_FontType_FontType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor();
+template<typename T>
+inline const std::string& Message_ExtendedTextMessage_FontType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ExtendedTextMessage_FontType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ExtendedTextMessage_FontType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ExtendedTextMessage_FontType_descriptor(), enum_t_value);
+}
+inline bool Message_ExtendedTextMessage_FontType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_FontType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_FontType>(
+    Message_ExtendedTextMessage_FontType_descriptor(), name, value);
+}
+enum Message_ExtendedTextMessage_InviteLinkGroupType : int {
+  Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT = 0,
+  Message_ExtendedTextMessage_InviteLinkGroupType_PARENT = 1,
+  Message_ExtendedTextMessage_InviteLinkGroupType_SUB = 2,
+  Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB = 3
+};
+bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value);
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT;
+constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB;
+constexpr int Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE = Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
+template<typename T>
+inline const std::string& Message_ExtendedTextMessage_InviteLinkGroupType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ExtendedTextMessage_InviteLinkGroupType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ExtendedTextMessage_InviteLinkGroupType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), enum_t_value);
+}
+inline bool Message_ExtendedTextMessage_InviteLinkGroupType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_InviteLinkGroupType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_InviteLinkGroupType>(
+    Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), name, value);
+}
+enum Message_ExtendedTextMessage_PreviewType : int {
+  Message_ExtendedTextMessage_PreviewType_NONE = 0,
+  Message_ExtendedTextMessage_PreviewType_VIDEO = 1
+};
+bool Message_ExtendedTextMessage_PreviewType_IsValid(int value);
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MIN = Message_ExtendedTextMessage_PreviewType_NONE;
+constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MAX = Message_ExtendedTextMessage_PreviewType_VIDEO;
+constexpr int Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE = Message_ExtendedTextMessage_PreviewType_PreviewType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor();
+template<typename T>
+inline const std::string& Message_ExtendedTextMessage_PreviewType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ExtendedTextMessage_PreviewType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ExtendedTextMessage_PreviewType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ExtendedTextMessage_PreviewType_descriptor(), enum_t_value);
+}
+inline bool Message_ExtendedTextMessage_PreviewType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_PreviewType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_PreviewType>(
+    Message_ExtendedTextMessage_PreviewType_descriptor(), name, value);
+}
+enum Message_GroupInviteMessage_GroupType : int {
+  Message_GroupInviteMessage_GroupType_DEFAULT = 0,
+  Message_GroupInviteMessage_GroupType_PARENT = 1
+};
+bool Message_GroupInviteMessage_GroupType_IsValid(int value);
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MIN = Message_GroupInviteMessage_GroupType_DEFAULT;
+constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MAX = Message_GroupInviteMessage_GroupType_PARENT;
+constexpr int Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE = Message_GroupInviteMessage_GroupType_GroupType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor();
+template<typename T>
+inline const std::string& Message_GroupInviteMessage_GroupType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_GroupInviteMessage_GroupType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_GroupInviteMessage_GroupType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_GroupInviteMessage_GroupType_descriptor(), enum_t_value);
+}
+inline bool Message_GroupInviteMessage_GroupType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_GroupInviteMessage_GroupType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_GroupInviteMessage_GroupType>(
+    Message_GroupInviteMessage_GroupType_descriptor(), name, value);
+}
+enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType : int {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN = 1,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI = 2
+};
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value);
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI;
+constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
+template<typename T>
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), enum_t_value);
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>(
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), name, value);
+}
+enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType : int {
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY = 1,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY = 2,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY = 3,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY = 4,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY = 5,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY = 6,
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY = 7
+};
+bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value);
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY;
+constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY;
+constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
+template<typename T>
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), enum_t_value);
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>(
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), name, value);
+}
+enum Message_HistorySyncNotification_HistorySyncType : int {
+  Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP = 0,
+  Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3 = 1,
+  Message_HistorySyncNotification_HistorySyncType_FULL = 2,
+  Message_HistorySyncNotification_HistorySyncType_RECENT = 3,
+  Message_HistorySyncNotification_HistorySyncType_PUSH_NAME = 4
+};
+bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value);
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN = Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP;
+constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX = Message_HistorySyncNotification_HistorySyncType_PUSH_NAME;
+constexpr int Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE = Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor();
+template<typename T>
+inline const std::string& Message_HistorySyncNotification_HistorySyncType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_HistorySyncNotification_HistorySyncType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_HistorySyncNotification_HistorySyncType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_HistorySyncNotification_HistorySyncType_descriptor(), enum_t_value);
+}
+inline bool Message_HistorySyncNotification_HistorySyncType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HistorySyncNotification_HistorySyncType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HistorySyncNotification_HistorySyncType>(
+    Message_HistorySyncNotification_HistorySyncType_descriptor(), name, value);
+}
+enum Message_InteractiveMessage_ShopMessage_Surface : int {
+  Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE = 0,
+  Message_InteractiveMessage_ShopMessage_Surface_FB = 1,
+  Message_InteractiveMessage_ShopMessage_Surface_IG = 2,
+  Message_InteractiveMessage_ShopMessage_Surface_WA = 3
+};
+bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value);
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN = Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE;
+constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX = Message_InteractiveMessage_ShopMessage_Surface_WA;
+constexpr int Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE = Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor();
+template<typename T>
+inline const std::string& Message_InteractiveMessage_ShopMessage_Surface_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_InteractiveMessage_ShopMessage_Surface>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_InteractiveMessage_ShopMessage_Surface_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_InteractiveMessage_ShopMessage_Surface_descriptor(), enum_t_value);
+}
+inline bool Message_InteractiveMessage_ShopMessage_Surface_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InteractiveMessage_ShopMessage_Surface* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_InteractiveMessage_ShopMessage_Surface>(
+    Message_InteractiveMessage_ShopMessage_Surface_descriptor(), name, value);
+}
+enum Message_InvoiceMessage_AttachmentType : int {
+  Message_InvoiceMessage_AttachmentType_IMAGE = 0,
+  Message_InvoiceMessage_AttachmentType_PDF = 1
+};
+bool Message_InvoiceMessage_AttachmentType_IsValid(int value);
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MIN = Message_InvoiceMessage_AttachmentType_IMAGE;
+constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MAX = Message_InvoiceMessage_AttachmentType_PDF;
+constexpr int Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE = Message_InvoiceMessage_AttachmentType_AttachmentType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor();
+template<typename T>
+inline const std::string& Message_InvoiceMessage_AttachmentType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_InvoiceMessage_AttachmentType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_InvoiceMessage_AttachmentType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_InvoiceMessage_AttachmentType_descriptor(), enum_t_value);
+}
+inline bool Message_InvoiceMessage_AttachmentType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InvoiceMessage_AttachmentType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_InvoiceMessage_AttachmentType>(
+    Message_InvoiceMessage_AttachmentType_descriptor(), name, value);
+}
+enum Message_ListMessage_ListType : int {
+  Message_ListMessage_ListType_UNKNOWN = 0,
+  Message_ListMessage_ListType_SINGLE_SELECT = 1,
+  Message_ListMessage_ListType_PRODUCT_LIST = 2
+};
+bool Message_ListMessage_ListType_IsValid(int value);
+constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MIN = Message_ListMessage_ListType_UNKNOWN;
+constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MAX = Message_ListMessage_ListType_PRODUCT_LIST;
+constexpr int Message_ListMessage_ListType_ListType_ARRAYSIZE = Message_ListMessage_ListType_ListType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor();
+template<typename T>
+inline const std::string& Message_ListMessage_ListType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ListMessage_ListType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ListMessage_ListType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ListMessage_ListType_descriptor(), enum_t_value);
+}
+inline bool Message_ListMessage_ListType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListMessage_ListType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ListMessage_ListType>(
+    Message_ListMessage_ListType_descriptor(), name, value);
+}
+enum Message_ListResponseMessage_ListType : int {
+  Message_ListResponseMessage_ListType_UNKNOWN = 0,
+  Message_ListResponseMessage_ListType_SINGLE_SELECT = 1
+};
+bool Message_ListResponseMessage_ListType_IsValid(int value);
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MIN = Message_ListResponseMessage_ListType_UNKNOWN;
+constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MAX = Message_ListResponseMessage_ListType_SINGLE_SELECT;
+constexpr int Message_ListResponseMessage_ListType_ListType_ARRAYSIZE = Message_ListResponseMessage_ListType_ListType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor();
+template<typename T>
+inline const std::string& Message_ListResponseMessage_ListType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ListResponseMessage_ListType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ListResponseMessage_ListType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ListResponseMessage_ListType_descriptor(), enum_t_value);
+}
+inline bool Message_ListResponseMessage_ListType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListResponseMessage_ListType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ListResponseMessage_ListType>(
+    Message_ListResponseMessage_ListType_descriptor(), name, value);
+}
+enum Message_OrderMessage_OrderStatus : int {
+  Message_OrderMessage_OrderStatus_INQUIRY = 1
+};
+bool Message_OrderMessage_OrderStatus_IsValid(int value);
+constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MIN = Message_OrderMessage_OrderStatus_INQUIRY;
+constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MAX = Message_OrderMessage_OrderStatus_INQUIRY;
+constexpr int Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE = Message_OrderMessage_OrderStatus_OrderStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor();
+template<typename T>
+inline const std::string& Message_OrderMessage_OrderStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_OrderMessage_OrderStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_OrderMessage_OrderStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_OrderMessage_OrderStatus_descriptor(), enum_t_value);
+}
+inline bool Message_OrderMessage_OrderStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_OrderMessage_OrderStatus>(
+    Message_OrderMessage_OrderStatus_descriptor(), name, value);
+}
+enum Message_OrderMessage_OrderSurface : int {
+  Message_OrderMessage_OrderSurface_CATALOG = 1
+};
+bool Message_OrderMessage_OrderSurface_IsValid(int value);
+constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MIN = Message_OrderMessage_OrderSurface_CATALOG;
+constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MAX = Message_OrderMessage_OrderSurface_CATALOG;
+constexpr int Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE = Message_OrderMessage_OrderSurface_OrderSurface_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor();
+template<typename T>
+inline const std::string& Message_OrderMessage_OrderSurface_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_OrderMessage_OrderSurface>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_OrderMessage_OrderSurface_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_OrderMessage_OrderSurface_descriptor(), enum_t_value);
+}
+inline bool Message_OrderMessage_OrderSurface_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderSurface* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_OrderMessage_OrderSurface>(
+    Message_OrderMessage_OrderSurface_descriptor(), name, value);
+}
+enum Message_PaymentInviteMessage_ServiceType : int {
+  Message_PaymentInviteMessage_ServiceType_UNKNOWN = 0,
+  Message_PaymentInviteMessage_ServiceType_FBPAY = 1,
+  Message_PaymentInviteMessage_ServiceType_NOVI = 2,
+  Message_PaymentInviteMessage_ServiceType_UPI = 3
+};
+bool Message_PaymentInviteMessage_ServiceType_IsValid(int value);
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MIN = Message_PaymentInviteMessage_ServiceType_UNKNOWN;
+constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MAX = Message_PaymentInviteMessage_ServiceType_UPI;
+constexpr int Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE = Message_PaymentInviteMessage_ServiceType_ServiceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor();
+template<typename T>
+inline const std::string& Message_PaymentInviteMessage_ServiceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_PaymentInviteMessage_ServiceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_PaymentInviteMessage_ServiceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_PaymentInviteMessage_ServiceType_descriptor(), enum_t_value);
+}
+inline bool Message_PaymentInviteMessage_ServiceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_PaymentInviteMessage_ServiceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_PaymentInviteMessage_ServiceType>(
+    Message_PaymentInviteMessage_ServiceType_descriptor(), name, value);
+}
+enum Message_ProtocolMessage_Type : int {
+  Message_ProtocolMessage_Type_REVOKE = 0,
+  Message_ProtocolMessage_Type_EPHEMERAL_SETTING = 3,
+  Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE = 4,
+  Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION = 5,
+  Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE = 6,
+  Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST = 7,
+  Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST = 8,
+  Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9,
+  Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10,
+  Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER = 11,
+  Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE = 12,
+  Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13
+};
+bool Message_ProtocolMessage_Type_IsValid(int value);
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MIN = Message_ProtocolMessage_Type_REVOKE;
+constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MAX = Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE;
+constexpr int Message_ProtocolMessage_Type_Type_ARRAYSIZE = Message_ProtocolMessage_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor();
+template<typename T>
+inline const std::string& Message_ProtocolMessage_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_ProtocolMessage_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_ProtocolMessage_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_ProtocolMessage_Type_descriptor(), enum_t_value);
+}
+inline bool Message_ProtocolMessage_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ProtocolMessage_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ProtocolMessage_Type>(
+    Message_ProtocolMessage_Type_descriptor(), name, value);
+}
+enum Message_VideoMessage_Attribution : int {
+  Message_VideoMessage_Attribution_NONE = 0,
+  Message_VideoMessage_Attribution_GIPHY = 1,
+  Message_VideoMessage_Attribution_TENOR = 2
+};
+bool Message_VideoMessage_Attribution_IsValid(int value);
+constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MIN = Message_VideoMessage_Attribution_NONE;
+constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MAX = Message_VideoMessage_Attribution_TENOR;
+constexpr int Message_VideoMessage_Attribution_Attribution_ARRAYSIZE = Message_VideoMessage_Attribution_Attribution_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor();
+template<typename T>
+inline const std::string& Message_VideoMessage_Attribution_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_VideoMessage_Attribution>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_VideoMessage_Attribution_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_VideoMessage_Attribution_descriptor(), enum_t_value);
+}
+inline bool Message_VideoMessage_Attribution_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_VideoMessage_Attribution* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_VideoMessage_Attribution>(
+    Message_VideoMessage_Attribution_descriptor(), name, value);
+}
+enum Message_RmrSource : int {
+  Message_RmrSource_FAVORITE_STICKER = 0,
+  Message_RmrSource_RECENT_STICKER = 1
+};
+bool Message_RmrSource_IsValid(int value);
+constexpr Message_RmrSource Message_RmrSource_RmrSource_MIN = Message_RmrSource_FAVORITE_STICKER;
+constexpr Message_RmrSource Message_RmrSource_RmrSource_MAX = Message_RmrSource_RECENT_STICKER;
+constexpr int Message_RmrSource_RmrSource_ARRAYSIZE = Message_RmrSource_RmrSource_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor();
+template<typename T>
+inline const std::string& Message_RmrSource_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Message_RmrSource>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Message_RmrSource_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Message_RmrSource_descriptor(), enum_t_value);
+}
+inline bool Message_RmrSource_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_RmrSource* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_RmrSource>(
+    Message_RmrSource_descriptor(), name, value);
+}
+enum PastParticipant_LeaveReason : int {
+  PastParticipant_LeaveReason_LEFT = 0,
+  PastParticipant_LeaveReason_REMOVED = 1
+};
+bool PastParticipant_LeaveReason_IsValid(int value);
+constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MIN = PastParticipant_LeaveReason_LEFT;
+constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MAX = PastParticipant_LeaveReason_REMOVED;
+constexpr int PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE = PastParticipant_LeaveReason_LeaveReason_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor();
+template<typename T>
+inline const std::string& PastParticipant_LeaveReason_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PastParticipant_LeaveReason>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PastParticipant_LeaveReason_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PastParticipant_LeaveReason_descriptor(), enum_t_value);
+}
+inline bool PastParticipant_LeaveReason_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PastParticipant_LeaveReason* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PastParticipant_LeaveReason>(
+    PastParticipant_LeaveReason_descriptor(), name, value);
+}
+enum PaymentBackground_Type : int {
+  PaymentBackground_Type_UNKNOWN = 0,
+  PaymentBackground_Type_DEFAULT = 1
+};
+bool PaymentBackground_Type_IsValid(int value);
+constexpr PaymentBackground_Type PaymentBackground_Type_Type_MIN = PaymentBackground_Type_UNKNOWN;
+constexpr PaymentBackground_Type PaymentBackground_Type_Type_MAX = PaymentBackground_Type_DEFAULT;
+constexpr int PaymentBackground_Type_Type_ARRAYSIZE = PaymentBackground_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor();
+template<typename T>
+inline const std::string& PaymentBackground_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PaymentBackground_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PaymentBackground_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PaymentBackground_Type_descriptor(), enum_t_value);
+}
+inline bool PaymentBackground_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentBackground_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentBackground_Type>(
+    PaymentBackground_Type_descriptor(), name, value);
+}
+enum PaymentInfo_Currency : int {
+  PaymentInfo_Currency_UNKNOWN_CURRENCY = 0,
+  PaymentInfo_Currency_INR = 1
+};
+bool PaymentInfo_Currency_IsValid(int value);
+constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MIN = PaymentInfo_Currency_UNKNOWN_CURRENCY;
+constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MAX = PaymentInfo_Currency_INR;
+constexpr int PaymentInfo_Currency_Currency_ARRAYSIZE = PaymentInfo_Currency_Currency_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor();
+template<typename T>
+inline const std::string& PaymentInfo_Currency_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PaymentInfo_Currency>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PaymentInfo_Currency_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PaymentInfo_Currency_descriptor(), enum_t_value);
+}
+inline bool PaymentInfo_Currency_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Currency* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_Currency>(
+    PaymentInfo_Currency_descriptor(), name, value);
+}
+enum PaymentInfo_Status : int {
+  PaymentInfo_Status_UNKNOWN_STATUS = 0,
+  PaymentInfo_Status_PROCESSING = 1,
+  PaymentInfo_Status_SENT = 2,
+  PaymentInfo_Status_NEED_TO_ACCEPT = 3,
+  PaymentInfo_Status_COMPLETE = 4,
+  PaymentInfo_Status_COULD_NOT_COMPLETE = 5,
+  PaymentInfo_Status_REFUNDED = 6,
+  PaymentInfo_Status_EXPIRED = 7,
+  PaymentInfo_Status_REJECTED = 8,
+  PaymentInfo_Status_CANCELLED = 9,
+  PaymentInfo_Status_WAITING_FOR_PAYER = 10,
+  PaymentInfo_Status_WAITING = 11
+};
+bool PaymentInfo_Status_IsValid(int value);
+constexpr PaymentInfo_Status PaymentInfo_Status_Status_MIN = PaymentInfo_Status_UNKNOWN_STATUS;
+constexpr PaymentInfo_Status PaymentInfo_Status_Status_MAX = PaymentInfo_Status_WAITING;
+constexpr int PaymentInfo_Status_Status_ARRAYSIZE = PaymentInfo_Status_Status_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor();
+template<typename T>
+inline const std::string& PaymentInfo_Status_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PaymentInfo_Status>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PaymentInfo_Status_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PaymentInfo_Status_descriptor(), enum_t_value);
+}
+inline bool PaymentInfo_Status_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Status* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_Status>(
+    PaymentInfo_Status_descriptor(), name, value);
+}
+enum PaymentInfo_TxnStatus : int {
+  PaymentInfo_TxnStatus_UNKNOWN = 0,
+  PaymentInfo_TxnStatus_PENDING_SETUP = 1,
+  PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP = 2,
+  PaymentInfo_TxnStatus_INIT = 3,
+  PaymentInfo_TxnStatus_SUCCESS = 4,
+  PaymentInfo_TxnStatus_COMPLETED = 5,
+  PaymentInfo_TxnStatus_FAILED = 6,
+  PaymentInfo_TxnStatus_FAILED_RISK = 7,
+  PaymentInfo_TxnStatus_FAILED_PROCESSING = 8,
+  PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING = 9,
+  PaymentInfo_TxnStatus_FAILED_DA = 10,
+  PaymentInfo_TxnStatus_FAILED_DA_FINAL = 11,
+  PaymentInfo_TxnStatus_REFUNDED_TXN = 12,
+  PaymentInfo_TxnStatus_REFUND_FAILED = 13,
+  PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING = 14,
+  PaymentInfo_TxnStatus_REFUND_FAILED_DA = 15,
+  PaymentInfo_TxnStatus_EXPIRED_TXN = 16,
+  PaymentInfo_TxnStatus_AUTH_CANCELED = 17,
+  PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING = 18,
+  PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED = 19,
+  PaymentInfo_TxnStatus_COLLECT_INIT = 20,
+  PaymentInfo_TxnStatus_COLLECT_SUCCESS = 21,
+  PaymentInfo_TxnStatus_COLLECT_FAILED = 22,
+  PaymentInfo_TxnStatus_COLLECT_FAILED_RISK = 23,
+  PaymentInfo_TxnStatus_COLLECT_REJECTED = 24,
+  PaymentInfo_TxnStatus_COLLECT_EXPIRED = 25,
+  PaymentInfo_TxnStatus_COLLECT_CANCELED = 26,
+  PaymentInfo_TxnStatus_COLLECT_CANCELLING = 27,
+  PaymentInfo_TxnStatus_IN_REVIEW = 28,
+  PaymentInfo_TxnStatus_REVERSAL_SUCCESS = 29,
+  PaymentInfo_TxnStatus_REVERSAL_PENDING = 30,
+  PaymentInfo_TxnStatus_REFUND_PENDING = 31
+};
+bool PaymentInfo_TxnStatus_IsValid(int value);
+constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MIN = PaymentInfo_TxnStatus_UNKNOWN;
+constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MAX = PaymentInfo_TxnStatus_REFUND_PENDING;
+constexpr int PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE = PaymentInfo_TxnStatus_TxnStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor();
+template<typename T>
+inline const std::string& PaymentInfo_TxnStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PaymentInfo_TxnStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PaymentInfo_TxnStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PaymentInfo_TxnStatus_descriptor(), enum_t_value);
+}
+inline bool PaymentInfo_TxnStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_TxnStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_TxnStatus>(
+    PaymentInfo_TxnStatus_descriptor(), name, value);
+}
+enum SyncdMutation_SyncdOperation : int {
+  SyncdMutation_SyncdOperation_SET = 0,
+  SyncdMutation_SyncdOperation_REMOVE = 1
+};
+bool SyncdMutation_SyncdOperation_IsValid(int value);
+constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MIN = SyncdMutation_SyncdOperation_SET;
+constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MAX = SyncdMutation_SyncdOperation_REMOVE;
+constexpr int SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE = SyncdMutation_SyncdOperation_SyncdOperation_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor();
+template<typename T>
+inline const std::string& SyncdMutation_SyncdOperation_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SyncdMutation_SyncdOperation>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SyncdMutation_SyncdOperation_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SyncdMutation_SyncdOperation_descriptor(), enum_t_value);
+}
+inline bool SyncdMutation_SyncdOperation_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncdMutation_SyncdOperation* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SyncdMutation_SyncdOperation>(
+    SyncdMutation_SyncdOperation_descriptor(), name, value);
+}
+enum WebFeatures_Flag : int {
+  WebFeatures_Flag_NOT_STARTED = 0,
+  WebFeatures_Flag_FORCE_UPGRADE = 1,
+  WebFeatures_Flag_DEVELOPMENT = 2,
+  WebFeatures_Flag_PRODUCTION = 3
+};
+bool WebFeatures_Flag_IsValid(int value);
+constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MIN = WebFeatures_Flag_NOT_STARTED;
+constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MAX = WebFeatures_Flag_PRODUCTION;
+constexpr int WebFeatures_Flag_Flag_ARRAYSIZE = WebFeatures_Flag_Flag_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor();
+template<typename T>
+inline const std::string& WebFeatures_Flag_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WebFeatures_Flag>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WebFeatures_Flag_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WebFeatures_Flag_descriptor(), enum_t_value);
+}
+inline bool WebFeatures_Flag_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebFeatures_Flag* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebFeatures_Flag>(
+    WebFeatures_Flag_descriptor(), name, value);
+}
+enum WebMessageInfo_BizPrivacyStatus : int {
+  WebMessageInfo_BizPrivacyStatus_E2EE = 0,
+  WebMessageInfo_BizPrivacyStatus_FB = 2,
+  WebMessageInfo_BizPrivacyStatus_BSP = 1,
+  WebMessageInfo_BizPrivacyStatus_BSP_AND_FB = 3
+};
+bool WebMessageInfo_BizPrivacyStatus_IsValid(int value);
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN = WebMessageInfo_BizPrivacyStatus_E2EE;
+constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX = WebMessageInfo_BizPrivacyStatus_BSP_AND_FB;
+constexpr int WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE = WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor();
+template<typename T>
+inline const std::string& WebMessageInfo_BizPrivacyStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WebMessageInfo_BizPrivacyStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WebMessageInfo_BizPrivacyStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WebMessageInfo_BizPrivacyStatus_descriptor(), enum_t_value);
+}
+inline bool WebMessageInfo_BizPrivacyStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_BizPrivacyStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_BizPrivacyStatus>(
+    WebMessageInfo_BizPrivacyStatus_descriptor(), name, value);
+}
+enum WebMessageInfo_Status : int {
+  WebMessageInfo_Status_ERROR = 0,
+  WebMessageInfo_Status_PENDING = 1,
+  WebMessageInfo_Status_SERVER_ACK = 2,
+  WebMessageInfo_Status_DELIVERY_ACK = 3,
+  WebMessageInfo_Status_READ = 4,
+  WebMessageInfo_Status_PLAYED = 5
+};
+bool WebMessageInfo_Status_IsValid(int value);
+constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MIN = WebMessageInfo_Status_ERROR;
+constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MAX = WebMessageInfo_Status_PLAYED;
+constexpr int WebMessageInfo_Status_Status_ARRAYSIZE = WebMessageInfo_Status_Status_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor();
+template<typename T>
+inline const std::string& WebMessageInfo_Status_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WebMessageInfo_Status>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WebMessageInfo_Status_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WebMessageInfo_Status_descriptor(), enum_t_value);
+}
+inline bool WebMessageInfo_Status_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_Status* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_Status>(
+    WebMessageInfo_Status_descriptor(), name, value);
+}
+enum WebMessageInfo_StubType : int {
+  WebMessageInfo_StubType_UNKNOWN = 0,
+  WebMessageInfo_StubType_REVOKE = 1,
+  WebMessageInfo_StubType_CIPHERTEXT = 2,
+  WebMessageInfo_StubType_FUTUREPROOF = 3,
+  WebMessageInfo_StubType_NON_VERIFIED_TRANSITION = 4,
+  WebMessageInfo_StubType_UNVERIFIED_TRANSITION = 5,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION = 6,
+  WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN = 7,
+  WebMessageInfo_StubType_VERIFIED_HIGH = 8,
+  WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN = 9,
+  WebMessageInfo_StubType_VERIFIED_INITIAL_LOW = 10,
+  WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH = 11,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE = 12,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH = 13,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW = 14,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW = 18,
+  WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19,
+  WebMessageInfo_StubType_GROUP_CREATE = 20,
+  WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT = 21,
+  WebMessageInfo_StubType_GROUP_CHANGE_ICON = 22,
+  WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK = 23,
+  WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION = 24,
+  WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT = 25,
+  WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE = 26,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD = 27,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE = 28,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE = 29,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE = 30,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE = 31,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE = 32,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER = 33,
+  WebMessageInfo_StubType_BROADCAST_CREATE = 34,
+  WebMessageInfo_StubType_BROADCAST_ADD = 35,
+  WebMessageInfo_StubType_BROADCAST_REMOVE = 36,
+  WebMessageInfo_StubType_GENERIC_NOTIFICATION = 37,
+  WebMessageInfo_StubType_E2E_IDENTITY_CHANGED = 38,
+  WebMessageInfo_StubType_E2E_ENCRYPTED = 39,
+  WebMessageInfo_StubType_CALL_MISSED_VOICE = 40,
+  WebMessageInfo_StubType_CALL_MISSED_VIDEO = 41,
+  WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER = 42,
+  WebMessageInfo_StubType_GROUP_DELETE = 43,
+  WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44,
+  WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE = 45,
+  WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO = 46,
+  WebMessageInfo_StubType_PAYMENT_CIPHERTEXT = 47,
+  WebMessageInfo_StubType_PAYMENT_FUTUREPROOF = 48,
+  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49,
+  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50,
+  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51,
+  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52,
+  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53,
+  WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54,
+  WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55,
+  WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56,
+  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED = 57,
+  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED = 58,
+  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED = 59,
+  WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60,
+  WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61,
+  WebMessageInfo_StubType_BIZ_INTRO_TOP = 62,
+  WebMessageInfo_StubType_BIZ_INTRO_BOTTOM = 63,
+  WebMessageInfo_StubType_BIZ_NAME_CHANGE = 64,
+  WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP = 65,
+  WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP = 66,
+  WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM = 67,
+  WebMessageInfo_StubType_OVERSIZED = 68,
+  WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69,
+  WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT = 70,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71,
+  WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING = 72,
+  WebMessageInfo_StubType_E2E_DEVICE_CHANGED = 73,
+  WebMessageInfo_StubType_VIEWED_ONCE = 74,
+  WebMessageInfo_StubType_E2E_ENCRYPTED_NOW = 75,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB = 77,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED = 79,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED = 81,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED = 86,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87,
+  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88,
+  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89,
+  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90,
+  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED = 94,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED = 96,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED = 100,
+  WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB = 101,
+  WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER = 102,
+  WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB = 103,
+  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104,
+  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105,
+  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106,
+  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107,
+  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108,
+  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109,
+  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110,
+  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114,
+  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116,
+  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117,
+  WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE = 118,
+  WebMessageInfo_StubType_GROUP_CREATING = 119,
+  WebMessageInfo_StubType_GROUP_CREATE_FAILED = 120,
+  WebMessageInfo_StubType_GROUP_BOUNCED = 121,
+  WebMessageInfo_StubType_BLOCK_CONTACT = 122,
+  WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED = 123,
+  WebMessageInfo_StubType_SYNC_FAILED = 124,
+  WebMessageInfo_StubType_SYNCING = 125,
+  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB = 126,
+  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP = 127,
+  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB = 128,
+  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP = 129,
+  WebMessageInfo_StubType_DISAPPEARING_MODE = 130,
+  WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED = 131,
+  WebMessageInfo_StubType_ADMIN_REVOKE = 132,
+  WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED = 133,
+  WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP = 134,
+  WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP = 135,
+  WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP = 136,
+  WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP = 137,
+  WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP = 138,
+  WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP = 139,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT = 140,
+  WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141,
+  WebMessageInfo_StubType_COMMUNITY_CREATE = 142,
+  WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT = 143,
+  WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144,
+  WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145,
+  WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP = 146,
+  WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE = 147,
+  WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE = 148,
+  WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED = 149
+};
+bool WebMessageInfo_StubType_IsValid(int value);
+constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MIN = WebMessageInfo_StubType_UNKNOWN;
+constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MAX = WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED;
+constexpr int WebMessageInfo_StubType_StubType_ARRAYSIZE = WebMessageInfo_StubType_StubType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor();
+template<typename T>
+inline const std::string& WebMessageInfo_StubType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WebMessageInfo_StubType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WebMessageInfo_StubType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WebMessageInfo_StubType_descriptor(), enum_t_value);
+}
+inline bool WebMessageInfo_StubType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_StubType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_StubType>(
+    WebMessageInfo_StubType_descriptor(), name, value);
+}
+enum KeepType : int {
+  UNKNOWN = 0,
+  KEEP_FOR_ALL = 1,
+  UNDO_KEEP_FOR_ALL = 2
+};
+bool KeepType_IsValid(int value);
+constexpr KeepType KeepType_MIN = UNKNOWN;
+constexpr KeepType KeepType_MAX = UNDO_KEEP_FOR_ALL;
+constexpr int KeepType_ARRAYSIZE = KeepType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor();
+template<typename T>
+inline const std::string& KeepType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, KeepType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function KeepType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    KeepType_descriptor(), enum_t_value);
+}
+inline bool KeepType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeepType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeepType>(
+    KeepType_descriptor(), name, value);
+}
+enum MediaVisibility : int {
+  DEFAULT = 0,
+  OFF = 1,
+  ON = 2
+};
+bool MediaVisibility_IsValid(int value);
+constexpr MediaVisibility MediaVisibility_MIN = DEFAULT;
+constexpr MediaVisibility MediaVisibility_MAX = ON;
+constexpr int MediaVisibility_ARRAYSIZE = MediaVisibility_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor();
+template<typename T>
+inline const std::string& MediaVisibility_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MediaVisibility>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MediaVisibility_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    MediaVisibility_descriptor(), enum_t_value);
+}
+inline bool MediaVisibility_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaVisibility* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MediaVisibility>(
+    MediaVisibility_descriptor(), name, value);
+}
+// ===================================================================
+
+class ADVDeviceIdentity final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVDeviceIdentity) */ {
+ public:
+  inline ADVDeviceIdentity() : ADVDeviceIdentity(nullptr) {}
+  ~ADVDeviceIdentity() override;
+  explicit PROTOBUF_CONSTEXPR ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ADVDeviceIdentity(const ADVDeviceIdentity& from);
+  ADVDeviceIdentity(ADVDeviceIdentity&& from) noexcept
+    : ADVDeviceIdentity() {
+    *this = ::std::move(from);
+  }
+
+  inline ADVDeviceIdentity& operator=(const ADVDeviceIdentity& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ADVDeviceIdentity& operator=(ADVDeviceIdentity&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ADVDeviceIdentity& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ADVDeviceIdentity* internal_default_instance() {
+    return reinterpret_cast<const ADVDeviceIdentity*>(
+               &_ADVDeviceIdentity_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ADVDeviceIdentity& a, ADVDeviceIdentity& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ADVDeviceIdentity* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ADVDeviceIdentity* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ADVDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ADVDeviceIdentity>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ADVDeviceIdentity& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ADVDeviceIdentity& from) {
+    ADVDeviceIdentity::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ADVDeviceIdentity* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ADVDeviceIdentity";
+  }
+  protected:
+  explicit ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTimestampFieldNumber = 2,
+    kRawIdFieldNumber = 1,
+    kKeyIndexFieldNumber = 3,
+  };
+  // optional uint64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  uint64_t timestamp() const;
+  void set_timestamp(uint64_t value);
+  private:
+  uint64_t _internal_timestamp() const;
+  void _internal_set_timestamp(uint64_t value);
+  public:
+
+  // optional uint32 rawId = 1;
+  bool has_rawid() const;
+  private:
+  bool _internal_has_rawid() const;
+  public:
+  void clear_rawid();
+  uint32_t rawid() const;
+  void set_rawid(uint32_t value);
+  private:
+  uint32_t _internal_rawid() const;
+  void _internal_set_rawid(uint32_t value);
+  public:
+
+  // optional uint32 keyIndex = 3;
+  bool has_keyindex() const;
+  private:
+  bool _internal_has_keyindex() const;
+  public:
+  void clear_keyindex();
+  uint32_t keyindex() const;
+  void set_keyindex(uint32_t value);
+  private:
+  uint32_t _internal_keyindex() const;
+  void _internal_set_keyindex(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ADVDeviceIdentity)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint64_t timestamp_;
+    uint32_t rawid_;
+    uint32_t keyindex_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ADVKeyIndexList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVKeyIndexList) */ {
+ public:
+  inline ADVKeyIndexList() : ADVKeyIndexList(nullptr) {}
+  ~ADVKeyIndexList() override;
+  explicit PROTOBUF_CONSTEXPR ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ADVKeyIndexList(const ADVKeyIndexList& from);
+  ADVKeyIndexList(ADVKeyIndexList&& from) noexcept
+    : ADVKeyIndexList() {
+    *this = ::std::move(from);
+  }
+
+  inline ADVKeyIndexList& operator=(const ADVKeyIndexList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ADVKeyIndexList& operator=(ADVKeyIndexList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ADVKeyIndexList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ADVKeyIndexList* internal_default_instance() {
+    return reinterpret_cast<const ADVKeyIndexList*>(
+               &_ADVKeyIndexList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ADVKeyIndexList& a, ADVKeyIndexList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ADVKeyIndexList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ADVKeyIndexList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ADVKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ADVKeyIndexList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ADVKeyIndexList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ADVKeyIndexList& from) {
+    ADVKeyIndexList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ADVKeyIndexList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ADVKeyIndexList";
+  }
+  protected:
+  explicit ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValidIndexesFieldNumber = 4,
+    kTimestampFieldNumber = 2,
+    kRawIdFieldNumber = 1,
+    kCurrentIndexFieldNumber = 3,
+  };
+  // repeated uint32 validIndexes = 4 [packed = true];
+  int validindexes_size() const;
+  private:
+  int _internal_validindexes_size() const;
+  public:
+  void clear_validindexes();
+  private:
+  uint32_t _internal_validindexes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_validindexes() const;
+  void _internal_add_validindexes(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_validindexes();
+  public:
+  uint32_t validindexes(int index) const;
+  void set_validindexes(int index, uint32_t value);
+  void add_validindexes(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      validindexes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_validindexes();
+
+  // optional uint64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  uint64_t timestamp() const;
+  void set_timestamp(uint64_t value);
+  private:
+  uint64_t _internal_timestamp() const;
+  void _internal_set_timestamp(uint64_t value);
+  public:
+
+  // optional uint32 rawId = 1;
+  bool has_rawid() const;
+  private:
+  bool _internal_has_rawid() const;
+  public:
+  void clear_rawid();
+  uint32_t rawid() const;
+  void set_rawid(uint32_t value);
+  private:
+  uint32_t _internal_rawid() const;
+  void _internal_set_rawid(uint32_t value);
+  public:
+
+  // optional uint32 currentIndex = 3;
+  bool has_currentindex() const;
+  private:
+  bool _internal_has_currentindex() const;
+  public:
+  void clear_currentindex();
+  uint32_t currentindex() const;
+  void set_currentindex(uint32_t value);
+  private:
+  uint32_t _internal_currentindex() const;
+  void _internal_set_currentindex(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ADVKeyIndexList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > validindexes_;
+    mutable std::atomic<int> _validindexes_cached_byte_size_;
+    uint64_t timestamp_;
+    uint32_t rawid_;
+    uint32_t currentindex_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ADVSignedDeviceIdentity final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentity) */ {
+ public:
+  inline ADVSignedDeviceIdentity() : ADVSignedDeviceIdentity(nullptr) {}
+  ~ADVSignedDeviceIdentity() override;
+  explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from);
+  ADVSignedDeviceIdentity(ADVSignedDeviceIdentity&& from) noexcept
+    : ADVSignedDeviceIdentity() {
+    *this = ::std::move(from);
+  }
+
+  inline ADVSignedDeviceIdentity& operator=(const ADVSignedDeviceIdentity& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ADVSignedDeviceIdentity& operator=(ADVSignedDeviceIdentity&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ADVSignedDeviceIdentity& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ADVSignedDeviceIdentity* internal_default_instance() {
+    return reinterpret_cast<const ADVSignedDeviceIdentity*>(
+               &_ADVSignedDeviceIdentity_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ADVSignedDeviceIdentity& a, ADVSignedDeviceIdentity& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ADVSignedDeviceIdentity* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ADVSignedDeviceIdentity* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ADVSignedDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ADVSignedDeviceIdentity>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ADVSignedDeviceIdentity& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ADVSignedDeviceIdentity& from) {
+    ADVSignedDeviceIdentity::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ADVSignedDeviceIdentity* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ADVSignedDeviceIdentity";
+  }
+  protected:
+  explicit ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kAccountSignatureKeyFieldNumber = 2,
+    kAccountSignatureFieldNumber = 3,
+    kDeviceSignatureFieldNumber = 4,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes accountSignatureKey = 2;
+  bool has_accountsignaturekey() const;
+  private:
+  bool _internal_has_accountsignaturekey() const;
+  public:
+  void clear_accountsignaturekey();
+  const std::string& accountsignaturekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_accountsignaturekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_accountsignaturekey();
+  PROTOBUF_NODISCARD std::string* release_accountsignaturekey();
+  void set_allocated_accountsignaturekey(std::string* accountsignaturekey);
+  private:
+  const std::string& _internal_accountsignaturekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignaturekey(const std::string& value);
+  std::string* _internal_mutable_accountsignaturekey();
+  public:
+
+  // optional bytes accountSignature = 3;
+  bool has_accountsignature() const;
+  private:
+  bool _internal_has_accountsignature() const;
+  public:
+  void clear_accountsignature();
+  const std::string& accountsignature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_accountsignature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_accountsignature();
+  PROTOBUF_NODISCARD std::string* release_accountsignature();
+  void set_allocated_accountsignature(std::string* accountsignature);
+  private:
+  const std::string& _internal_accountsignature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value);
+  std::string* _internal_mutable_accountsignature();
+  public:
+
+  // optional bytes deviceSignature = 4;
+  bool has_devicesignature() const;
+  private:
+  bool _internal_has_devicesignature() const;
+  public:
+  void clear_devicesignature();
+  const std::string& devicesignature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_devicesignature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_devicesignature();
+  PROTOBUF_NODISCARD std::string* release_devicesignature();
+  void set_allocated_devicesignature(std::string* devicesignature);
+  private:
+  const std::string& _internal_devicesignature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicesignature(const std::string& value);
+  std::string* _internal_mutable_devicesignature();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentity)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignaturekey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicesignature_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ADVSignedDeviceIdentityHMAC final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentityHMAC) */ {
+ public:
+  inline ADVSignedDeviceIdentityHMAC() : ADVSignedDeviceIdentityHMAC(nullptr) {}
+  ~ADVSignedDeviceIdentityHMAC() override;
+  explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from);
+  ADVSignedDeviceIdentityHMAC(ADVSignedDeviceIdentityHMAC&& from) noexcept
+    : ADVSignedDeviceIdentityHMAC() {
+    *this = ::std::move(from);
+  }
+
+  inline ADVSignedDeviceIdentityHMAC& operator=(const ADVSignedDeviceIdentityHMAC& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ADVSignedDeviceIdentityHMAC& operator=(ADVSignedDeviceIdentityHMAC&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ADVSignedDeviceIdentityHMAC& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ADVSignedDeviceIdentityHMAC* internal_default_instance() {
+    return reinterpret_cast<const ADVSignedDeviceIdentityHMAC*>(
+               &_ADVSignedDeviceIdentityHMAC_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ADVSignedDeviceIdentityHMAC& a, ADVSignedDeviceIdentityHMAC& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ADVSignedDeviceIdentityHMAC* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ADVSignedDeviceIdentityHMAC* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ADVSignedDeviceIdentityHMAC* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ADVSignedDeviceIdentityHMAC>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ADVSignedDeviceIdentityHMAC& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ADVSignedDeviceIdentityHMAC& from) {
+    ADVSignedDeviceIdentityHMAC::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ADVSignedDeviceIdentityHMAC* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ADVSignedDeviceIdentityHMAC";
+  }
+  protected:
+  explicit ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kHmacFieldNumber = 2,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes hmac = 2;
+  bool has_hmac() const;
+  private:
+  bool _internal_has_hmac() const;
+  public:
+  void clear_hmac();
+  const std::string& hmac() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hmac(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hmac();
+  PROTOBUF_NODISCARD std::string* release_hmac();
+  void set_allocated_hmac(std::string* hmac);
+  private:
+  const std::string& _internal_hmac() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hmac(const std::string& value);
+  std::string* _internal_mutable_hmac();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentityHMAC)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hmac_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ADVSignedKeyIndexList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedKeyIndexList) */ {
+ public:
+  inline ADVSignedKeyIndexList() : ADVSignedKeyIndexList(nullptr) {}
+  ~ADVSignedKeyIndexList() override;
+  explicit PROTOBUF_CONSTEXPR ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from);
+  ADVSignedKeyIndexList(ADVSignedKeyIndexList&& from) noexcept
+    : ADVSignedKeyIndexList() {
+    *this = ::std::move(from);
+  }
+
+  inline ADVSignedKeyIndexList& operator=(const ADVSignedKeyIndexList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ADVSignedKeyIndexList& operator=(ADVSignedKeyIndexList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ADVSignedKeyIndexList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ADVSignedKeyIndexList* internal_default_instance() {
+    return reinterpret_cast<const ADVSignedKeyIndexList*>(
+               &_ADVSignedKeyIndexList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ADVSignedKeyIndexList& a, ADVSignedKeyIndexList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ADVSignedKeyIndexList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ADVSignedKeyIndexList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ADVSignedKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ADVSignedKeyIndexList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ADVSignedKeyIndexList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ADVSignedKeyIndexList& from) {
+    ADVSignedKeyIndexList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ADVSignedKeyIndexList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ADVSignedKeyIndexList";
+  }
+  protected:
+  explicit ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kAccountSignatureFieldNumber = 2,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes accountSignature = 2;
+  bool has_accountsignature() const;
+  private:
+  bool _internal_has_accountsignature() const;
+  public:
+  void clear_accountsignature();
+  const std::string& accountsignature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_accountsignature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_accountsignature();
+  PROTOBUF_NODISCARD std::string* release_accountsignature();
+  void set_allocated_accountsignature(std::string* accountsignature);
+  private:
+  const std::string& _internal_accountsignature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value);
+  std::string* _internal_mutable_accountsignature();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ADVSignedKeyIndexList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ActionLink final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ActionLink) */ {
+ public:
+  inline ActionLink() : ActionLink(nullptr) {}
+  ~ActionLink() override;
+  explicit PROTOBUF_CONSTEXPR ActionLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ActionLink(const ActionLink& from);
+  ActionLink(ActionLink&& from) noexcept
+    : ActionLink() {
+    *this = ::std::move(from);
+  }
+
+  inline ActionLink& operator=(const ActionLink& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ActionLink& operator=(ActionLink&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ActionLink& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ActionLink* internal_default_instance() {
+    return reinterpret_cast<const ActionLink*>(
+               &_ActionLink_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ActionLink& a, ActionLink& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ActionLink* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ActionLink* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ActionLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ActionLink>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ActionLink& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ActionLink& from) {
+    ActionLink::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ActionLink* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ActionLink";
+  }
+  protected:
+  explicit ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kButtonTitleFieldNumber = 2,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string buttonTitle = 2;
+  bool has_buttontitle() const;
+  private:
+  bool _internal_has_buttontitle() const;
+  public:
+  void clear_buttontitle();
+  const std::string& buttontitle() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_buttontitle(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_buttontitle();
+  PROTOBUF_NODISCARD std::string* release_buttontitle();
+  void set_allocated_buttontitle(std::string* buttontitle);
+  private:
+  const std::string& _internal_buttontitle() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontitle(const std::string& value);
+  std::string* _internal_mutable_buttontitle();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ActionLink)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontitle_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AutoDownloadSettings final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.AutoDownloadSettings) */ {
+ public:
+  inline AutoDownloadSettings() : AutoDownloadSettings(nullptr) {}
+  ~AutoDownloadSettings() override;
+  explicit PROTOBUF_CONSTEXPR AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AutoDownloadSettings(const AutoDownloadSettings& from);
+  AutoDownloadSettings(AutoDownloadSettings&& from) noexcept
+    : AutoDownloadSettings() {
+    *this = ::std::move(from);
+  }
+
+  inline AutoDownloadSettings& operator=(const AutoDownloadSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AutoDownloadSettings& operator=(AutoDownloadSettings&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AutoDownloadSettings& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AutoDownloadSettings* internal_default_instance() {
+    return reinterpret_cast<const AutoDownloadSettings*>(
+               &_AutoDownloadSettings_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(AutoDownloadSettings& a, AutoDownloadSettings& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AutoDownloadSettings* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AutoDownloadSettings* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AutoDownloadSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AutoDownloadSettings>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AutoDownloadSettings& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AutoDownloadSettings& from) {
+    AutoDownloadSettings::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AutoDownloadSettings* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.AutoDownloadSettings";
+  }
+  protected:
+  explicit AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDownloadImagesFieldNumber = 1,
+    kDownloadAudioFieldNumber = 2,
+    kDownloadVideoFieldNumber = 3,
+    kDownloadDocumentsFieldNumber = 4,
+  };
+  // optional bool downloadImages = 1;
+  bool has_downloadimages() const;
+  private:
+  bool _internal_has_downloadimages() const;
+  public:
+  void clear_downloadimages();
+  bool downloadimages() const;
+  void set_downloadimages(bool value);
+  private:
+  bool _internal_downloadimages() const;
+  void _internal_set_downloadimages(bool value);
+  public:
+
+  // optional bool downloadAudio = 2;
+  bool has_downloadaudio() const;
+  private:
+  bool _internal_has_downloadaudio() const;
+  public:
+  void clear_downloadaudio();
+  bool downloadaudio() const;
+  void set_downloadaudio(bool value);
+  private:
+  bool _internal_downloadaudio() const;
+  void _internal_set_downloadaudio(bool value);
+  public:
+
+  // optional bool downloadVideo = 3;
+  bool has_downloadvideo() const;
+  private:
+  bool _internal_has_downloadvideo() const;
+  public:
+  void clear_downloadvideo();
+  bool downloadvideo() const;
+  void set_downloadvideo(bool value);
+  private:
+  bool _internal_downloadvideo() const;
+  void _internal_set_downloadvideo(bool value);
+  public:
+
+  // optional bool downloadDocuments = 4;
+  bool has_downloaddocuments() const;
+  private:
+  bool _internal_has_downloaddocuments() const;
+  public:
+  void clear_downloaddocuments();
+  bool downloaddocuments() const;
+  void set_downloaddocuments(bool value);
+  private:
+  bool _internal_downloaddocuments() const;
+  void _internal_set_downloaddocuments(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.AutoDownloadSettings)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool downloadimages_;
+    bool downloadaudio_;
+    bool downloadvideo_;
+    bool downloaddocuments_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BizAccountLinkInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountLinkInfo) */ {
+ public:
+  inline BizAccountLinkInfo() : BizAccountLinkInfo(nullptr) {}
+  ~BizAccountLinkInfo() override;
+  explicit PROTOBUF_CONSTEXPR BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BizAccountLinkInfo(const BizAccountLinkInfo& from);
+  BizAccountLinkInfo(BizAccountLinkInfo&& from) noexcept
+    : BizAccountLinkInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline BizAccountLinkInfo& operator=(const BizAccountLinkInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BizAccountLinkInfo& operator=(BizAccountLinkInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BizAccountLinkInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BizAccountLinkInfo* internal_default_instance() {
+    return reinterpret_cast<const BizAccountLinkInfo*>(
+               &_BizAccountLinkInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(BizAccountLinkInfo& a, BizAccountLinkInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BizAccountLinkInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BizAccountLinkInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BizAccountLinkInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BizAccountLinkInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BizAccountLinkInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BizAccountLinkInfo& from) {
+    BizAccountLinkInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BizAccountLinkInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.BizAccountLinkInfo";
+  }
+  protected:
+  explicit BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef BizAccountLinkInfo_AccountType AccountType;
+  static constexpr AccountType ENTERPRISE =
+    BizAccountLinkInfo_AccountType_ENTERPRISE;
+  static inline bool AccountType_IsValid(int value) {
+    return BizAccountLinkInfo_AccountType_IsValid(value);
+  }
+  static constexpr AccountType AccountType_MIN =
+    BizAccountLinkInfo_AccountType_AccountType_MIN;
+  static constexpr AccountType AccountType_MAX =
+    BizAccountLinkInfo_AccountType_AccountType_MAX;
+  static constexpr int AccountType_ARRAYSIZE =
+    BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  AccountType_descriptor() {
+    return BizAccountLinkInfo_AccountType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& AccountType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, AccountType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function AccountType_Name.");
+    return BizAccountLinkInfo_AccountType_Name(enum_t_value);
+  }
+  static inline bool AccountType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      AccountType* value) {
+    return BizAccountLinkInfo_AccountType_Parse(name, value);
+  }
+
+  typedef BizAccountLinkInfo_HostStorageType HostStorageType;
+  static constexpr HostStorageType ON_PREMISE =
+    BizAccountLinkInfo_HostStorageType_ON_PREMISE;
+  static constexpr HostStorageType FACEBOOK =
+    BizAccountLinkInfo_HostStorageType_FACEBOOK;
+  static inline bool HostStorageType_IsValid(int value) {
+    return BizAccountLinkInfo_HostStorageType_IsValid(value);
+  }
+  static constexpr HostStorageType HostStorageType_MIN =
+    BizAccountLinkInfo_HostStorageType_HostStorageType_MIN;
+  static constexpr HostStorageType HostStorageType_MAX =
+    BizAccountLinkInfo_HostStorageType_HostStorageType_MAX;
+  static constexpr int HostStorageType_ARRAYSIZE =
+    BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HostStorageType_descriptor() {
+    return BizAccountLinkInfo_HostStorageType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HostStorageType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HostStorageType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HostStorageType_Name.");
+    return BizAccountLinkInfo_HostStorageType_Name(enum_t_value);
+  }
+  static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HostStorageType* value) {
+    return BizAccountLinkInfo_HostStorageType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWhatsappAcctNumberFieldNumber = 2,
+    kWhatsappBizAcctFbidFieldNumber = 1,
+    kIssueTimeFieldNumber = 3,
+    kHostStorageFieldNumber = 4,
+    kAccountTypeFieldNumber = 5,
+  };
+  // optional string whatsappAcctNumber = 2;
+  bool has_whatsappacctnumber() const;
+  private:
+  bool _internal_has_whatsappacctnumber() const;
+  public:
+  void clear_whatsappacctnumber();
+  const std::string& whatsappacctnumber() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_whatsappacctnumber(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_whatsappacctnumber();
+  PROTOBUF_NODISCARD std::string* release_whatsappacctnumber();
+  void set_allocated_whatsappacctnumber(std::string* whatsappacctnumber);
+  private:
+  const std::string& _internal_whatsappacctnumber() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_whatsappacctnumber(const std::string& value);
+  std::string* _internal_mutable_whatsappacctnumber();
+  public:
+
+  // optional uint64 whatsappBizAcctFbid = 1;
+  bool has_whatsappbizacctfbid() const;
+  private:
+  bool _internal_has_whatsappbizacctfbid() const;
+  public:
+  void clear_whatsappbizacctfbid();
+  uint64_t whatsappbizacctfbid() const;
+  void set_whatsappbizacctfbid(uint64_t value);
+  private:
+  uint64_t _internal_whatsappbizacctfbid() const;
+  void _internal_set_whatsappbizacctfbid(uint64_t value);
+  public:
+
+  // optional uint64 issueTime = 3;
+  bool has_issuetime() const;
+  private:
+  bool _internal_has_issuetime() const;
+  public:
+  void clear_issuetime();
+  uint64_t issuetime() const;
+  void set_issuetime(uint64_t value);
+  private:
+  uint64_t _internal_issuetime() const;
+  void _internal_set_issuetime(uint64_t value);
+  public:
+
+  // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
+  bool has_hoststorage() const;
+  private:
+  bool _internal_has_hoststorage() const;
+  public:
+  void clear_hoststorage();
+  ::proto::BizAccountLinkInfo_HostStorageType hoststorage() const;
+  void set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value);
+  private:
+  ::proto::BizAccountLinkInfo_HostStorageType _internal_hoststorage() const;
+  void _internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value);
+  public:
+
+  // optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
+  bool has_accounttype() const;
+  private:
+  bool _internal_has_accounttype() const;
+  public:
+  void clear_accounttype();
+  ::proto::BizAccountLinkInfo_AccountType accounttype() const;
+  void set_accounttype(::proto::BizAccountLinkInfo_AccountType value);
+  private:
+  ::proto::BizAccountLinkInfo_AccountType _internal_accounttype() const;
+  void _internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.BizAccountLinkInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr whatsappacctnumber_;
+    uint64_t whatsappbizacctfbid_;
+    uint64_t issuetime_;
+    int hoststorage_;
+    int accounttype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BizAccountPayload final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountPayload) */ {
+ public:
+  inline BizAccountPayload() : BizAccountPayload(nullptr) {}
+  ~BizAccountPayload() override;
+  explicit PROTOBUF_CONSTEXPR BizAccountPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BizAccountPayload(const BizAccountPayload& from);
+  BizAccountPayload(BizAccountPayload&& from) noexcept
+    : BizAccountPayload() {
+    *this = ::std::move(from);
+  }
+
+  inline BizAccountPayload& operator=(const BizAccountPayload& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BizAccountPayload& operator=(BizAccountPayload&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BizAccountPayload& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BizAccountPayload* internal_default_instance() {
+    return reinterpret_cast<const BizAccountPayload*>(
+               &_BizAccountPayload_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(BizAccountPayload& a, BizAccountPayload& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BizAccountPayload* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BizAccountPayload* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BizAccountPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BizAccountPayload>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BizAccountPayload& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BizAccountPayload& from) {
+    BizAccountPayload::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BizAccountPayload* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.BizAccountPayload";
+  }
+  protected:
+  explicit BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBizAcctLinkInfoFieldNumber = 2,
+    kVnameCertFieldNumber = 1,
+  };
+  // optional bytes bizAcctLinkInfo = 2;
+  bool has_bizacctlinkinfo() const;
+  private:
+  bool _internal_has_bizacctlinkinfo() const;
+  public:
+  void clear_bizacctlinkinfo();
+  const std::string& bizacctlinkinfo() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bizacctlinkinfo();
+  PROTOBUF_NODISCARD std::string* release_bizacctlinkinfo();
+  void set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo);
+  private:
+  const std::string& _internal_bizacctlinkinfo() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizacctlinkinfo(const std::string& value);
+  std::string* _internal_mutable_bizacctlinkinfo();
+  public:
+
+  // optional .proto.VerifiedNameCertificate vnameCert = 1;
+  bool has_vnamecert() const;
+  private:
+  bool _internal_has_vnamecert() const;
+  public:
+  void clear_vnamecert();
+  const ::proto::VerifiedNameCertificate& vnamecert() const;
+  PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert();
+  ::proto::VerifiedNameCertificate* mutable_vnamecert();
+  void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert);
+  private:
+  const ::proto::VerifiedNameCertificate& _internal_vnamecert() const;
+  ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert();
+  public:
+  void unsafe_arena_set_allocated_vnamecert(
+      ::proto::VerifiedNameCertificate* vnamecert);
+  ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert();
+
+  // @@protoc_insertion_point(class_scope:proto.BizAccountPayload)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizacctlinkinfo_;
+    ::proto::VerifiedNameCertificate* vnamecert_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BizIdentityInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizIdentityInfo) */ {
+ public:
+  inline BizIdentityInfo() : BizIdentityInfo(nullptr) {}
+  ~BizIdentityInfo() override;
+  explicit PROTOBUF_CONSTEXPR BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BizIdentityInfo(const BizIdentityInfo& from);
+  BizIdentityInfo(BizIdentityInfo&& from) noexcept
+    : BizIdentityInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline BizIdentityInfo& operator=(const BizIdentityInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BizIdentityInfo& operator=(BizIdentityInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BizIdentityInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BizIdentityInfo* internal_default_instance() {
+    return reinterpret_cast<const BizIdentityInfo*>(
+               &_BizIdentityInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(BizIdentityInfo& a, BizIdentityInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BizIdentityInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BizIdentityInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BizIdentityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BizIdentityInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BizIdentityInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BizIdentityInfo& from) {
+    BizIdentityInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BizIdentityInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.BizIdentityInfo";
+  }
+  protected:
+  explicit BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef BizIdentityInfo_ActualActorsType ActualActorsType;
+  static constexpr ActualActorsType SELF =
+    BizIdentityInfo_ActualActorsType_SELF;
+  static constexpr ActualActorsType BSP =
+    BizIdentityInfo_ActualActorsType_BSP;
+  static inline bool ActualActorsType_IsValid(int value) {
+    return BizIdentityInfo_ActualActorsType_IsValid(value);
+  }
+  static constexpr ActualActorsType ActualActorsType_MIN =
+    BizIdentityInfo_ActualActorsType_ActualActorsType_MIN;
+  static constexpr ActualActorsType ActualActorsType_MAX =
+    BizIdentityInfo_ActualActorsType_ActualActorsType_MAX;
+  static constexpr int ActualActorsType_ARRAYSIZE =
+    BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ActualActorsType_descriptor() {
+    return BizIdentityInfo_ActualActorsType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ActualActorsType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ActualActorsType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ActualActorsType_Name.");
+    return BizIdentityInfo_ActualActorsType_Name(enum_t_value);
+  }
+  static inline bool ActualActorsType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ActualActorsType* value) {
+    return BizIdentityInfo_ActualActorsType_Parse(name, value);
+  }
+
+  typedef BizIdentityInfo_HostStorageType HostStorageType;
+  static constexpr HostStorageType ON_PREMISE =
+    BizIdentityInfo_HostStorageType_ON_PREMISE;
+  static constexpr HostStorageType FACEBOOK =
+    BizIdentityInfo_HostStorageType_FACEBOOK;
+  static inline bool HostStorageType_IsValid(int value) {
+    return BizIdentityInfo_HostStorageType_IsValid(value);
+  }
+  static constexpr HostStorageType HostStorageType_MIN =
+    BizIdentityInfo_HostStorageType_HostStorageType_MIN;
+  static constexpr HostStorageType HostStorageType_MAX =
+    BizIdentityInfo_HostStorageType_HostStorageType_MAX;
+  static constexpr int HostStorageType_ARRAYSIZE =
+    BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HostStorageType_descriptor() {
+    return BizIdentityInfo_HostStorageType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HostStorageType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HostStorageType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HostStorageType_Name.");
+    return BizIdentityInfo_HostStorageType_Name(enum_t_value);
+  }
+  static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HostStorageType* value) {
+    return BizIdentityInfo_HostStorageType_Parse(name, value);
+  }
+
+  typedef BizIdentityInfo_VerifiedLevelValue VerifiedLevelValue;
+  static constexpr VerifiedLevelValue UNKNOWN =
+    BizIdentityInfo_VerifiedLevelValue_UNKNOWN;
+  static constexpr VerifiedLevelValue LOW =
+    BizIdentityInfo_VerifiedLevelValue_LOW;
+  static constexpr VerifiedLevelValue HIGH =
+    BizIdentityInfo_VerifiedLevelValue_HIGH;
+  static inline bool VerifiedLevelValue_IsValid(int value) {
+    return BizIdentityInfo_VerifiedLevelValue_IsValid(value);
+  }
+  static constexpr VerifiedLevelValue VerifiedLevelValue_MIN =
+    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN;
+  static constexpr VerifiedLevelValue VerifiedLevelValue_MAX =
+    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX;
+  static constexpr int VerifiedLevelValue_ARRAYSIZE =
+    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  VerifiedLevelValue_descriptor() {
+    return BizIdentityInfo_VerifiedLevelValue_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& VerifiedLevelValue_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, VerifiedLevelValue>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function VerifiedLevelValue_Name.");
+    return BizIdentityInfo_VerifiedLevelValue_Name(enum_t_value);
+  }
+  static inline bool VerifiedLevelValue_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      VerifiedLevelValue* value) {
+    return BizIdentityInfo_VerifiedLevelValue_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVnameCertFieldNumber = 2,
+    kVlevelFieldNumber = 1,
+    kSignedFieldNumber = 3,
+    kRevokedFieldNumber = 4,
+    kHostStorageFieldNumber = 5,
+    kActualActorsFieldNumber = 6,
+    kPrivacyModeTsFieldNumber = 7,
+    kFeatureControlsFieldNumber = 8,
+  };
+  // optional .proto.VerifiedNameCertificate vnameCert = 2;
+  bool has_vnamecert() const;
+  private:
+  bool _internal_has_vnamecert() const;
+  public:
+  void clear_vnamecert();
+  const ::proto::VerifiedNameCertificate& vnamecert() const;
+  PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert();
+  ::proto::VerifiedNameCertificate* mutable_vnamecert();
+  void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert);
+  private:
+  const ::proto::VerifiedNameCertificate& _internal_vnamecert() const;
+  ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert();
+  public:
+  void unsafe_arena_set_allocated_vnamecert(
+      ::proto::VerifiedNameCertificate* vnamecert);
+  ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert();
+
+  // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
+  bool has_vlevel() const;
+  private:
+  bool _internal_has_vlevel() const;
+  public:
+  void clear_vlevel();
+  ::proto::BizIdentityInfo_VerifiedLevelValue vlevel() const;
+  void set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value);
+  private:
+  ::proto::BizIdentityInfo_VerifiedLevelValue _internal_vlevel() const;
+  void _internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value);
+  public:
+
+  // optional bool signed = 3;
+  bool has_signed_() const;
+  private:
+  bool _internal_has_signed_() const;
+  public:
+  void clear_signed_();
+  bool signed_() const;
+  void set_signed_(bool value);
+  private:
+  bool _internal_signed_() const;
+  void _internal_set_signed_(bool value);
+  public:
+
+  // optional bool revoked = 4;
+  bool has_revoked() const;
+  private:
+  bool _internal_has_revoked() const;
+  public:
+  void clear_revoked();
+  bool revoked() const;
+  void set_revoked(bool value);
+  private:
+  bool _internal_revoked() const;
+  void _internal_set_revoked(bool value);
+  public:
+
+  // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
+  bool has_hoststorage() const;
+  private:
+  bool _internal_has_hoststorage() const;
+  public:
+  void clear_hoststorage();
+  ::proto::BizIdentityInfo_HostStorageType hoststorage() const;
+  void set_hoststorage(::proto::BizIdentityInfo_HostStorageType value);
+  private:
+  ::proto::BizIdentityInfo_HostStorageType _internal_hoststorage() const;
+  void _internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value);
+  public:
+
+  // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
+  bool has_actualactors() const;
+  private:
+  bool _internal_has_actualactors() const;
+  public:
+  void clear_actualactors();
+  ::proto::BizIdentityInfo_ActualActorsType actualactors() const;
+  void set_actualactors(::proto::BizIdentityInfo_ActualActorsType value);
+  private:
+  ::proto::BizIdentityInfo_ActualActorsType _internal_actualactors() const;
+  void _internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value);
+  public:
+
+  // optional uint64 privacyModeTs = 7;
+  bool has_privacymodets() const;
+  private:
+  bool _internal_has_privacymodets() const;
+  public:
+  void clear_privacymodets();
+  uint64_t privacymodets() const;
+  void set_privacymodets(uint64_t value);
+  private:
+  uint64_t _internal_privacymodets() const;
+  void _internal_set_privacymodets(uint64_t value);
+  public:
+
+  // optional uint64 featureControls = 8;
+  bool has_featurecontrols() const;
+  private:
+  bool _internal_has_featurecontrols() const;
+  public:
+  void clear_featurecontrols();
+  uint64_t featurecontrols() const;
+  void set_featurecontrols(uint64_t value);
+  private:
+  uint64_t _internal_featurecontrols() const;
+  void _internal_set_featurecontrols(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.BizIdentityInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::VerifiedNameCertificate* vnamecert_;
+    int vlevel_;
+    bool signed__;
+    bool revoked_;
+    int hoststorage_;
+    int actualactors_;
+    uint64_t privacymodets_;
+    uint64_t featurecontrols_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CertChain_NoiseCertificate_Details final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate.Details) */ {
+ public:
+  inline CertChain_NoiseCertificate_Details() : CertChain_NoiseCertificate_Details(nullptr) {}
+  ~CertChain_NoiseCertificate_Details() override;
+  explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from);
+  CertChain_NoiseCertificate_Details(CertChain_NoiseCertificate_Details&& from) noexcept
+    : CertChain_NoiseCertificate_Details() {
+    *this = ::std::move(from);
+  }
+
+  inline CertChain_NoiseCertificate_Details& operator=(const CertChain_NoiseCertificate_Details& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CertChain_NoiseCertificate_Details& operator=(CertChain_NoiseCertificate_Details&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CertChain_NoiseCertificate_Details& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CertChain_NoiseCertificate_Details* internal_default_instance() {
+    return reinterpret_cast<const CertChain_NoiseCertificate_Details*>(
+               &_CertChain_NoiseCertificate_Details_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(CertChain_NoiseCertificate_Details& a, CertChain_NoiseCertificate_Details& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CertChain_NoiseCertificate_Details* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CertChain_NoiseCertificate_Details* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CertChain_NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CertChain_NoiseCertificate_Details>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CertChain_NoiseCertificate_Details& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CertChain_NoiseCertificate_Details& from) {
+    CertChain_NoiseCertificate_Details::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CertChain_NoiseCertificate_Details* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.CertChain.NoiseCertificate.Details";
+  }
+  protected:
+  explicit CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 3,
+    kSerialFieldNumber = 1,
+    kIssuerSerialFieldNumber = 2,
+    kNotBeforeFieldNumber = 4,
+    kNotAfterFieldNumber = 5,
+  };
+  // optional bytes key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_NODISCARD std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional uint32 serial = 1;
+  bool has_serial() const;
+  private:
+  bool _internal_has_serial() const;
+  public:
+  void clear_serial();
+  uint32_t serial() const;
+  void set_serial(uint32_t value);
+  private:
+  uint32_t _internal_serial() const;
+  void _internal_set_serial(uint32_t value);
+  public:
+
+  // optional uint32 issuerSerial = 2;
+  bool has_issuerserial() const;
+  private:
+  bool _internal_has_issuerserial() const;
+  public:
+  void clear_issuerserial();
+  uint32_t issuerserial() const;
+  void set_issuerserial(uint32_t value);
+  private:
+  uint32_t _internal_issuerserial() const;
+  void _internal_set_issuerserial(uint32_t value);
+  public:
+
+  // optional uint64 notBefore = 4;
+  bool has_notbefore() const;
+  private:
+  bool _internal_has_notbefore() const;
+  public:
+  void clear_notbefore();
+  uint64_t notbefore() const;
+  void set_notbefore(uint64_t value);
+  private:
+  uint64_t _internal_notbefore() const;
+  void _internal_set_notbefore(uint64_t value);
+  public:
+
+  // optional uint64 notAfter = 5;
+  bool has_notafter() const;
+  private:
+  bool _internal_has_notafter() const;
+  public:
+  void clear_notafter();
+  uint64_t notafter() const;
+  void set_notafter(uint64_t value);
+  private:
+  uint64_t _internal_notafter() const;
+  void _internal_set_notafter(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate.Details)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+    uint32_t serial_;
+    uint32_t issuerserial_;
+    uint64_t notbefore_;
+    uint64_t notafter_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CertChain_NoiseCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate) */ {
+ public:
+  inline CertChain_NoiseCertificate() : CertChain_NoiseCertificate(nullptr) {}
+  ~CertChain_NoiseCertificate() override;
+  explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from);
+  CertChain_NoiseCertificate(CertChain_NoiseCertificate&& from) noexcept
+    : CertChain_NoiseCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline CertChain_NoiseCertificate& operator=(const CertChain_NoiseCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CertChain_NoiseCertificate& operator=(CertChain_NoiseCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CertChain_NoiseCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CertChain_NoiseCertificate* internal_default_instance() {
+    return reinterpret_cast<const CertChain_NoiseCertificate*>(
+               &_CertChain_NoiseCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(CertChain_NoiseCertificate& a, CertChain_NoiseCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CertChain_NoiseCertificate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CertChain_NoiseCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CertChain_NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CertChain_NoiseCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CertChain_NoiseCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CertChain_NoiseCertificate& from) {
+    CertChain_NoiseCertificate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CertChain_NoiseCertificate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.CertChain.NoiseCertificate";
+  }
+  protected:
+  explicit CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CertChain_NoiseCertificate_Details Details;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_NODISCARD std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CertChain final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain) */ {
+ public:
+  inline CertChain() : CertChain(nullptr) {}
+  ~CertChain() override;
+  explicit PROTOBUF_CONSTEXPR CertChain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CertChain(const CertChain& from);
+  CertChain(CertChain&& from) noexcept
+    : CertChain() {
+    *this = ::std::move(from);
+  }
+
+  inline CertChain& operator=(const CertChain& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CertChain& operator=(CertChain&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CertChain& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CertChain* internal_default_instance() {
+    return reinterpret_cast<const CertChain*>(
+               &_CertChain_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(CertChain& a, CertChain& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CertChain* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CertChain* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CertChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CertChain>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CertChain& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CertChain& from) {
+    CertChain::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CertChain* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.CertChain";
+  }
+  protected:
+  explicit CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CertChain_NoiseCertificate NoiseCertificate;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLeafFieldNumber = 1,
+    kIntermediateFieldNumber = 2,
+  };
+  // optional .proto.CertChain.NoiseCertificate leaf = 1;
+  bool has_leaf() const;
+  private:
+  bool _internal_has_leaf() const;
+  public:
+  void clear_leaf();
+  const ::proto::CertChain_NoiseCertificate& leaf() const;
+  PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_leaf();
+  ::proto::CertChain_NoiseCertificate* mutable_leaf();
+  void set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf);
+  private:
+  const ::proto::CertChain_NoiseCertificate& _internal_leaf() const;
+  ::proto::CertChain_NoiseCertificate* _internal_mutable_leaf();
+  public:
+  void unsafe_arena_set_allocated_leaf(
+      ::proto::CertChain_NoiseCertificate* leaf);
+  ::proto::CertChain_NoiseCertificate* unsafe_arena_release_leaf();
+
+  // optional .proto.CertChain.NoiseCertificate intermediate = 2;
+  bool has_intermediate() const;
+  private:
+  bool _internal_has_intermediate() const;
+  public:
+  void clear_intermediate();
+  const ::proto::CertChain_NoiseCertificate& intermediate() const;
+  PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_intermediate();
+  ::proto::CertChain_NoiseCertificate* mutable_intermediate();
+  void set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate);
+  private:
+  const ::proto::CertChain_NoiseCertificate& _internal_intermediate() const;
+  ::proto::CertChain_NoiseCertificate* _internal_mutable_intermediate();
+  public:
+  void unsafe_arena_set_allocated_intermediate(
+      ::proto::CertChain_NoiseCertificate* intermediate);
+  ::proto::CertChain_NoiseCertificate* unsafe_arena_release_intermediate();
+
+  // @@protoc_insertion_point(class_scope:proto.CertChain)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::CertChain_NoiseCertificate* leaf_;
+    ::proto::CertChain_NoiseCertificate* intermediate_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Chain final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Chain) */ {
+ public:
+  inline Chain() : Chain(nullptr) {}
+  ~Chain() override;
+  explicit PROTOBUF_CONSTEXPR Chain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Chain(const Chain& from);
+  Chain(Chain&& from) noexcept
+    : Chain() {
+    *this = ::std::move(from);
+  }
+
+  inline Chain& operator=(const Chain& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Chain& operator=(Chain&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Chain& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Chain* internal_default_instance() {
+    return reinterpret_cast<const Chain*>(
+               &_Chain_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(Chain& a, Chain& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Chain* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Chain* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Chain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Chain>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Chain& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Chain& from) {
+    Chain::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Chain* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Chain";
+  }
+  protected:
+  explicit Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageKeysFieldNumber = 4,
+    kSenderRatchetKeyFieldNumber = 1,
+    kSenderRatchetKeyPrivateFieldNumber = 2,
+    kChainKeyFieldNumber = 3,
+  };
+  // repeated .proto.MessageKey messageKeys = 4;
+  int messagekeys_size() const;
+  private:
+  int _internal_messagekeys_size() const;
+  public:
+  void clear_messagekeys();
+  ::proto::MessageKey* mutable_messagekeys(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >*
+      mutable_messagekeys();
+  private:
+  const ::proto::MessageKey& _internal_messagekeys(int index) const;
+  ::proto::MessageKey* _internal_add_messagekeys();
+  public:
+  const ::proto::MessageKey& messagekeys(int index) const;
+  ::proto::MessageKey* add_messagekeys();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >&
+      messagekeys() const;
+
+  // optional bytes senderRatchetKey = 1;
+  bool has_senderratchetkey() const;
+  private:
+  bool _internal_has_senderratchetkey() const;
+  public:
+  void clear_senderratchetkey();
+  const std::string& senderratchetkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_senderratchetkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_senderratchetkey();
+  PROTOBUF_NODISCARD std::string* release_senderratchetkey();
+  void set_allocated_senderratchetkey(std::string* senderratchetkey);
+  private:
+  const std::string& _internal_senderratchetkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkey(const std::string& value);
+  std::string* _internal_mutable_senderratchetkey();
+  public:
+
+  // optional bytes senderRatchetKeyPrivate = 2;
+  bool has_senderratchetkeyprivate() const;
+  private:
+  bool _internal_has_senderratchetkeyprivate() const;
+  public:
+  void clear_senderratchetkeyprivate();
+  const std::string& senderratchetkeyprivate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_senderratchetkeyprivate();
+  PROTOBUF_NODISCARD std::string* release_senderratchetkeyprivate();
+  void set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate);
+  private:
+  const std::string& _internal_senderratchetkeyprivate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkeyprivate(const std::string& value);
+  std::string* _internal_mutable_senderratchetkeyprivate();
+  public:
+
+  // optional .proto.ChainKey chainKey = 3;
+  bool has_chainkey() const;
+  private:
+  bool _internal_has_chainkey() const;
+  public:
+  void clear_chainkey();
+  const ::proto::ChainKey& chainkey() const;
+  PROTOBUF_NODISCARD ::proto::ChainKey* release_chainkey();
+  ::proto::ChainKey* mutable_chainkey();
+  void set_allocated_chainkey(::proto::ChainKey* chainkey);
+  private:
+  const ::proto::ChainKey& _internal_chainkey() const;
+  ::proto::ChainKey* _internal_mutable_chainkey();
+  public:
+  void unsafe_arena_set_allocated_chainkey(
+      ::proto::ChainKey* chainkey);
+  ::proto::ChainKey* unsafe_arena_release_chainkey();
+
+  // @@protoc_insertion_point(class_scope:proto.Chain)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey > messagekeys_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkeyprivate_;
+    ::proto::ChainKey* chainkey_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ChainKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ChainKey) */ {
+ public:
+  inline ChainKey() : ChainKey(nullptr) {}
+  ~ChainKey() override;
+  explicit PROTOBUF_CONSTEXPR ChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ChainKey(const ChainKey& from);
+  ChainKey(ChainKey&& from) noexcept
+    : ChainKey() {
+    *this = ::std::move(from);
+  }
+
+  inline ChainKey& operator=(const ChainKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ChainKey& operator=(ChainKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ChainKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ChainKey* internal_default_instance() {
+    return reinterpret_cast<const ChainKey*>(
+               &_ChainKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(ChainKey& a, ChainKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ChainKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ChainKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ChainKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ChainKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ChainKey& from) {
+    ChainKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ChainKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ChainKey";
+  }
+  protected:
+  explicit ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 2,
+    kIndexFieldNumber = 1,
+  };
+  // optional bytes key = 2;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_NODISCARD std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional uint32 index = 1;
+  bool has_index() const;
+  private:
+  bool _internal_has_index() const;
+  public:
+  void clear_index();
+  uint32_t index() const;
+  void set_index(uint32_t value);
+  private:
+  uint32_t _internal_index() const;
+  void _internal_set_index(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ChainKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+    uint32_t index_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_DNSSource final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DNSSource) */ {
+ public:
+  inline ClientPayload_DNSSource() : ClientPayload_DNSSource(nullptr) {}
+  ~ClientPayload_DNSSource() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_DNSSource(const ClientPayload_DNSSource& from);
+  ClientPayload_DNSSource(ClientPayload_DNSSource&& from) noexcept
+    : ClientPayload_DNSSource() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_DNSSource& operator=(const ClientPayload_DNSSource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_DNSSource& operator=(ClientPayload_DNSSource&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_DNSSource& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_DNSSource* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_DNSSource*>(
+               &_ClientPayload_DNSSource_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(ClientPayload_DNSSource& a, ClientPayload_DNSSource& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_DNSSource* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_DNSSource* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_DNSSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_DNSSource>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_DNSSource& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_DNSSource& from) {
+    ClientPayload_DNSSource::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_DNSSource* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.DNSSource";
+  }
+  protected:
+  explicit ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPayload_DNSSource_DNSResolutionMethod DNSResolutionMethod;
+  static constexpr DNSResolutionMethod SYSTEM =
+    ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM;
+  static constexpr DNSResolutionMethod GOOGLE =
+    ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE;
+  static constexpr DNSResolutionMethod HARDCODED =
+    ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED;
+  static constexpr DNSResolutionMethod OVERRIDE =
+    ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE;
+  static constexpr DNSResolutionMethod FALLBACK =
+    ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK;
+  static inline bool DNSResolutionMethod_IsValid(int value) {
+    return ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value);
+  }
+  static constexpr DNSResolutionMethod DNSResolutionMethod_MIN =
+    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN;
+  static constexpr DNSResolutionMethod DNSResolutionMethod_MAX =
+    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX;
+  static constexpr int DNSResolutionMethod_ARRAYSIZE =
+    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DNSResolutionMethod_descriptor() {
+    return ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DNSResolutionMethod_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DNSResolutionMethod>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DNSResolutionMethod_Name.");
+    return ClientPayload_DNSSource_DNSResolutionMethod_Name(enum_t_value);
+  }
+  static inline bool DNSResolutionMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DNSResolutionMethod* value) {
+    return ClientPayload_DNSSource_DNSResolutionMethod_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDnsMethodFieldNumber = 15,
+    kAppCachedFieldNumber = 16,
+  };
+  // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
+  bool has_dnsmethod() const;
+  private:
+  bool _internal_has_dnsmethod() const;
+  public:
+  void clear_dnsmethod();
+  ::proto::ClientPayload_DNSSource_DNSResolutionMethod dnsmethod() const;
+  void set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value);
+  private:
+  ::proto::ClientPayload_DNSSource_DNSResolutionMethod _internal_dnsmethod() const;
+  void _internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value);
+  public:
+
+  // optional bool appCached = 16;
+  bool has_appcached() const;
+  private:
+  bool _internal_has_appcached() const;
+  public:
+  void clear_appcached();
+  bool appcached() const;
+  void set_appcached(bool value);
+  private:
+  bool _internal_appcached() const;
+  void _internal_set_appcached(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.DNSSource)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int dnsmethod_;
+    bool appcached_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_DevicePairingRegistrationData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DevicePairingRegistrationData) */ {
+ public:
+  inline ClientPayload_DevicePairingRegistrationData() : ClientPayload_DevicePairingRegistrationData(nullptr) {}
+  ~ClientPayload_DevicePairingRegistrationData() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from);
+  ClientPayload_DevicePairingRegistrationData(ClientPayload_DevicePairingRegistrationData&& from) noexcept
+    : ClientPayload_DevicePairingRegistrationData() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_DevicePairingRegistrationData& operator=(const ClientPayload_DevicePairingRegistrationData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_DevicePairingRegistrationData& operator=(ClientPayload_DevicePairingRegistrationData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_DevicePairingRegistrationData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_DevicePairingRegistrationData* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_DevicePairingRegistrationData*>(
+               &_ClientPayload_DevicePairingRegistrationData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(ClientPayload_DevicePairingRegistrationData& a, ClientPayload_DevicePairingRegistrationData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_DevicePairingRegistrationData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_DevicePairingRegistrationData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_DevicePairingRegistrationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_DevicePairingRegistrationData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_DevicePairingRegistrationData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_DevicePairingRegistrationData& from) {
+    ClientPayload_DevicePairingRegistrationData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_DevicePairingRegistrationData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.DevicePairingRegistrationData";
+  }
+  protected:
+  explicit ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kERegidFieldNumber = 1,
+    kEKeytypeFieldNumber = 2,
+    kEIdentFieldNumber = 3,
+    kESkeyIdFieldNumber = 4,
+    kESkeyValFieldNumber = 5,
+    kESkeySigFieldNumber = 6,
+    kBuildHashFieldNumber = 7,
+    kDevicePropsFieldNumber = 8,
+  };
+  // optional bytes eRegid = 1;
+  bool has_eregid() const;
+  private:
+  bool _internal_has_eregid() const;
+  public:
+  void clear_eregid();
+  const std::string& eregid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_eregid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_eregid();
+  PROTOBUF_NODISCARD std::string* release_eregid();
+  void set_allocated_eregid(std::string* eregid);
+  private:
+  const std::string& _internal_eregid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eregid(const std::string& value);
+  std::string* _internal_mutable_eregid();
+  public:
+
+  // optional bytes eKeytype = 2;
+  bool has_ekeytype() const;
+  private:
+  bool _internal_has_ekeytype() const;
+  public:
+  void clear_ekeytype();
+  const std::string& ekeytype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ekeytype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ekeytype();
+  PROTOBUF_NODISCARD std::string* release_ekeytype();
+  void set_allocated_ekeytype(std::string* ekeytype);
+  private:
+  const std::string& _internal_ekeytype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ekeytype(const std::string& value);
+  std::string* _internal_mutable_ekeytype();
+  public:
+
+  // optional bytes eIdent = 3;
+  bool has_eident() const;
+  private:
+  bool _internal_has_eident() const;
+  public:
+  void clear_eident();
+  const std::string& eident() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_eident(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_eident();
+  PROTOBUF_NODISCARD std::string* release_eident();
+  void set_allocated_eident(std::string* eident);
+  private:
+  const std::string& _internal_eident() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eident(const std::string& value);
+  std::string* _internal_mutable_eident();
+  public:
+
+  // optional bytes eSkeyId = 4;
+  bool has_eskeyid() const;
+  private:
+  bool _internal_has_eskeyid() const;
+  public:
+  void clear_eskeyid();
+  const std::string& eskeyid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_eskeyid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_eskeyid();
+  PROTOBUF_NODISCARD std::string* release_eskeyid();
+  void set_allocated_eskeyid(std::string* eskeyid);
+  private:
+  const std::string& _internal_eskeyid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyid(const std::string& value);
+  std::string* _internal_mutable_eskeyid();
+  public:
+
+  // optional bytes eSkeyVal = 5;
+  bool has_eskeyval() const;
+  private:
+  bool _internal_has_eskeyval() const;
+  public:
+  void clear_eskeyval();
+  const std::string& eskeyval() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_eskeyval(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_eskeyval();
+  PROTOBUF_NODISCARD std::string* release_eskeyval();
+  void set_allocated_eskeyval(std::string* eskeyval);
+  private:
+  const std::string& _internal_eskeyval() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyval(const std::string& value);
+  std::string* _internal_mutable_eskeyval();
+  public:
+
+  // optional bytes eSkeySig = 6;
+  bool has_eskeysig() const;
+  private:
+  bool _internal_has_eskeysig() const;
+  public:
+  void clear_eskeysig();
+  const std::string& eskeysig() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_eskeysig(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_eskeysig();
+  PROTOBUF_NODISCARD std::string* release_eskeysig();
+  void set_allocated_eskeysig(std::string* eskeysig);
+  private:
+  const std::string& _internal_eskeysig() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeysig(const std::string& value);
+  std::string* _internal_mutable_eskeysig();
+  public:
+
+  // optional bytes buildHash = 7;
+  bool has_buildhash() const;
+  private:
+  bool _internal_has_buildhash() const;
+  public:
+  void clear_buildhash();
+  const std::string& buildhash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_buildhash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_buildhash();
+  PROTOBUF_NODISCARD std::string* release_buildhash();
+  void set_allocated_buildhash(std::string* buildhash);
+  private:
+  const std::string& _internal_buildhash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buildhash(const std::string& value);
+  std::string* _internal_mutable_buildhash();
+  public:
+
+  // optional bytes deviceProps = 8;
+  bool has_deviceprops() const;
+  private:
+  bool _internal_has_deviceprops() const;
+  public:
+  void clear_deviceprops();
+  const std::string& deviceprops() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_deviceprops(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_deviceprops();
+  PROTOBUF_NODISCARD std::string* release_deviceprops();
+  void set_allocated_deviceprops(std::string* deviceprops);
+  private:
+  const std::string& _internal_deviceprops() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceprops(const std::string& value);
+  std::string* _internal_mutable_deviceprops();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.DevicePairingRegistrationData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eregid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ekeytype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eident_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyval_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeysig_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buildhash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceprops_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_UserAgent_AppVersion final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent.AppVersion) */ {
+ public:
+  inline ClientPayload_UserAgent_AppVersion() : ClientPayload_UserAgent_AppVersion(nullptr) {}
+  ~ClientPayload_UserAgent_AppVersion() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from);
+  ClientPayload_UserAgent_AppVersion(ClientPayload_UserAgent_AppVersion&& from) noexcept
+    : ClientPayload_UserAgent_AppVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_UserAgent_AppVersion& operator=(const ClientPayload_UserAgent_AppVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_UserAgent_AppVersion& operator=(ClientPayload_UserAgent_AppVersion&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_UserAgent_AppVersion& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_UserAgent_AppVersion* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_UserAgent_AppVersion*>(
+               &_ClientPayload_UserAgent_AppVersion_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(ClientPayload_UserAgent_AppVersion& a, ClientPayload_UserAgent_AppVersion& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_UserAgent_AppVersion* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_UserAgent_AppVersion* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_UserAgent_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_UserAgent_AppVersion>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_UserAgent_AppVersion& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_UserAgent_AppVersion& from) {
+    ClientPayload_UserAgent_AppVersion::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_UserAgent_AppVersion* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.UserAgent.AppVersion";
+  }
+  protected:
+  explicit ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrimaryFieldNumber = 1,
+    kSecondaryFieldNumber = 2,
+    kTertiaryFieldNumber = 3,
+    kQuaternaryFieldNumber = 4,
+    kQuinaryFieldNumber = 5,
+  };
+  // optional uint32 primary = 1;
+  bool has_primary() const;
+  private:
+  bool _internal_has_primary() const;
+  public:
+  void clear_primary();
+  uint32_t primary() const;
+  void set_primary(uint32_t value);
+  private:
+  uint32_t _internal_primary() const;
+  void _internal_set_primary(uint32_t value);
+  public:
+
+  // optional uint32 secondary = 2;
+  bool has_secondary() const;
+  private:
+  bool _internal_has_secondary() const;
+  public:
+  void clear_secondary();
+  uint32_t secondary() const;
+  void set_secondary(uint32_t value);
+  private:
+  uint32_t _internal_secondary() const;
+  void _internal_set_secondary(uint32_t value);
+  public:
+
+  // optional uint32 tertiary = 3;
+  bool has_tertiary() const;
+  private:
+  bool _internal_has_tertiary() const;
+  public:
+  void clear_tertiary();
+  uint32_t tertiary() const;
+  void set_tertiary(uint32_t value);
+  private:
+  uint32_t _internal_tertiary() const;
+  void _internal_set_tertiary(uint32_t value);
+  public:
+
+  // optional uint32 quaternary = 4;
+  bool has_quaternary() const;
+  private:
+  bool _internal_has_quaternary() const;
+  public:
+  void clear_quaternary();
+  uint32_t quaternary() const;
+  void set_quaternary(uint32_t value);
+  private:
+  uint32_t _internal_quaternary() const;
+  void _internal_set_quaternary(uint32_t value);
+  public:
+
+  // optional uint32 quinary = 5;
+  bool has_quinary() const;
+  private:
+  bool _internal_has_quinary() const;
+  public:
+  void clear_quinary();
+  uint32_t quinary() const;
+  void set_quinary(uint32_t value);
+  private:
+  uint32_t _internal_quinary() const;
+  void _internal_set_quinary(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent.AppVersion)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t primary_;
+    uint32_t secondary_;
+    uint32_t tertiary_;
+    uint32_t quaternary_;
+    uint32_t quinary_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_UserAgent final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent) */ {
+ public:
+  inline ClientPayload_UserAgent() : ClientPayload_UserAgent(nullptr) {}
+  ~ClientPayload_UserAgent() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_UserAgent(const ClientPayload_UserAgent& from);
+  ClientPayload_UserAgent(ClientPayload_UserAgent&& from) noexcept
+    : ClientPayload_UserAgent() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_UserAgent& operator=(const ClientPayload_UserAgent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_UserAgent& operator=(ClientPayload_UserAgent&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_UserAgent& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_UserAgent* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_UserAgent*>(
+               &_ClientPayload_UserAgent_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(ClientPayload_UserAgent& a, ClientPayload_UserAgent& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_UserAgent* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_UserAgent* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_UserAgent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_UserAgent>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_UserAgent& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_UserAgent& from) {
+    ClientPayload_UserAgent::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_UserAgent* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.UserAgent";
+  }
+  protected:
+  explicit ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPayload_UserAgent_AppVersion AppVersion;
+
+  typedef ClientPayload_UserAgent_Platform Platform;
+  static constexpr Platform ANDROID =
+    ClientPayload_UserAgent_Platform_ANDROID;
+  static constexpr Platform IOS =
+    ClientPayload_UserAgent_Platform_IOS;
+  static constexpr Platform WINDOWS_PHONE =
+    ClientPayload_UserAgent_Platform_WINDOWS_PHONE;
+  static constexpr Platform BLACKBERRY =
+    ClientPayload_UserAgent_Platform_BLACKBERRY;
+  static constexpr Platform BLACKBERRYX =
+    ClientPayload_UserAgent_Platform_BLACKBERRYX;
+  static constexpr Platform S40 =
+    ClientPayload_UserAgent_Platform_S40;
+  static constexpr Platform S60 =
+    ClientPayload_UserAgent_Platform_S60;
+  static constexpr Platform PYTHON_CLIENT =
+    ClientPayload_UserAgent_Platform_PYTHON_CLIENT;
+  static constexpr Platform TIZEN =
+    ClientPayload_UserAgent_Platform_TIZEN;
+  static constexpr Platform ENTERPRISE =
+    ClientPayload_UserAgent_Platform_ENTERPRISE;
+  static constexpr Platform SMB_ANDROID =
+    ClientPayload_UserAgent_Platform_SMB_ANDROID;
+  static constexpr Platform KAIOS =
+    ClientPayload_UserAgent_Platform_KAIOS;
+  static constexpr Platform SMB_IOS =
+    ClientPayload_UserAgent_Platform_SMB_IOS;
+  static constexpr Platform WINDA =
+    ClientPayload_UserAgent_Platform_WINDOWS;
+  static constexpr Platform WEB =
+    ClientPayload_UserAgent_Platform_WEB;
+  static constexpr Platform PORTAL =
+    ClientPayload_UserAgent_Platform_PORTAL;
+  static constexpr Platform GREEN_ANDROID =
+    ClientPayload_UserAgent_Platform_GREEN_ANDROID;
+  static constexpr Platform GREEN_IPHONE =
+    ClientPayload_UserAgent_Platform_GREEN_IPHONE;
+  static constexpr Platform BLUE_ANDROID =
+    ClientPayload_UserAgent_Platform_BLUE_ANDROID;
+  static constexpr Platform BLUE_IPHONE =
+    ClientPayload_UserAgent_Platform_BLUE_IPHONE;
+  static constexpr Platform FBLITE_ANDROID =
+    ClientPayload_UserAgent_Platform_FBLITE_ANDROID;
+  static constexpr Platform MLITE_ANDROID =
+    ClientPayload_UserAgent_Platform_MLITE_ANDROID;
+  static constexpr Platform IGLITE_ANDROID =
+    ClientPayload_UserAgent_Platform_IGLITE_ANDROID;
+  static constexpr Platform PAGE =
+    ClientPayload_UserAgent_Platform_PAGE;
+  static constexpr Platform MACOS =
+    ClientPayload_UserAgent_Platform_MACOS;
+  static constexpr Platform OCULUS_MSG =
+    ClientPayload_UserAgent_Platform_OCULUS_MSG;
+  static constexpr Platform OCULUS_CALL =
+    ClientPayload_UserAgent_Platform_OCULUS_CALL;
+  static constexpr Platform MILAN =
+    ClientPayload_UserAgent_Platform_MILAN;
+  static constexpr Platform CAPI =
+    ClientPayload_UserAgent_Platform_CAPI;
+  static inline bool Platform_IsValid(int value) {
+    return ClientPayload_UserAgent_Platform_IsValid(value);
+  }
+  static constexpr Platform Platform_MIN =
+    ClientPayload_UserAgent_Platform_Platform_MIN;
+  static constexpr Platform Platform_MAX =
+    ClientPayload_UserAgent_Platform_Platform_MAX;
+  static constexpr int Platform_ARRAYSIZE =
+    ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Platform_descriptor() {
+    return ClientPayload_UserAgent_Platform_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Platform_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Platform>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Platform_Name.");
+    return ClientPayload_UserAgent_Platform_Name(enum_t_value);
+  }
+  static inline bool Platform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Platform* value) {
+    return ClientPayload_UserAgent_Platform_Parse(name, value);
+  }
+
+  typedef ClientPayload_UserAgent_ReleaseChannel ReleaseChannel;
+  static constexpr ReleaseChannel RELEASE =
+    ClientPayload_UserAgent_ReleaseChannel_RELEASE;
+  static constexpr ReleaseChannel BETA =
+    ClientPayload_UserAgent_ReleaseChannel_BETA;
+  static constexpr ReleaseChannel ALPHA =
+    ClientPayload_UserAgent_ReleaseChannel_ALPHA;
+  static constexpr ReleaseChannel DEBUG =
+    ClientPayload_UserAgent_ReleaseChannel_DEBUG;
+  static inline bool ReleaseChannel_IsValid(int value) {
+    return ClientPayload_UserAgent_ReleaseChannel_IsValid(value);
+  }
+  static constexpr ReleaseChannel ReleaseChannel_MIN =
+    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN;
+  static constexpr ReleaseChannel ReleaseChannel_MAX =
+    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX;
+  static constexpr int ReleaseChannel_ARRAYSIZE =
+    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ReleaseChannel_descriptor() {
+    return ClientPayload_UserAgent_ReleaseChannel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ReleaseChannel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ReleaseChannel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ReleaseChannel_Name.");
+    return ClientPayload_UserAgent_ReleaseChannel_Name(enum_t_value);
+  }
+  static inline bool ReleaseChannel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ReleaseChannel* value) {
+    return ClientPayload_UserAgent_ReleaseChannel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMccFieldNumber = 3,
+    kMncFieldNumber = 4,
+    kOsVersionFieldNumber = 5,
+    kManufacturerFieldNumber = 6,
+    kDeviceFieldNumber = 7,
+    kOsBuildNumberFieldNumber = 8,
+    kPhoneIdFieldNumber = 9,
+    kLocaleLanguageIso6391FieldNumber = 11,
+    kLocaleCountryIso31661Alpha2FieldNumber = 12,
+    kDeviceBoardFieldNumber = 13,
+    kAppVersionFieldNumber = 2,
+    kPlatformFieldNumber = 1,
+    kReleaseChannelFieldNumber = 10,
+  };
+  // optional string mcc = 3;
+  bool has_mcc() const;
+  private:
+  bool _internal_has_mcc() const;
+  public:
+  void clear_mcc();
+  const std::string& mcc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mcc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mcc();
+  PROTOBUF_NODISCARD std::string* release_mcc();
+  void set_allocated_mcc(std::string* mcc);
+  private:
+  const std::string& _internal_mcc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mcc(const std::string& value);
+  std::string* _internal_mutable_mcc();
+  public:
+
+  // optional string mnc = 4;
+  bool has_mnc() const;
+  private:
+  bool _internal_has_mnc() const;
+  public:
+  void clear_mnc();
+  const std::string& mnc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mnc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mnc();
+  PROTOBUF_NODISCARD std::string* release_mnc();
+  void set_allocated_mnc(std::string* mnc);
+  private:
+  const std::string& _internal_mnc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnc(const std::string& value);
+  std::string* _internal_mutable_mnc();
+  public:
+
+  // optional string osVersion = 5;
+  bool has_osversion() const;
+  private:
+  bool _internal_has_osversion() const;
+  public:
+  void clear_osversion();
+  const std::string& osversion() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_osversion(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_osversion();
+  PROTOBUF_NODISCARD std::string* release_osversion();
+  void set_allocated_osversion(std::string* osversion);
+  private:
+  const std::string& _internal_osversion() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_osversion(const std::string& value);
+  std::string* _internal_mutable_osversion();
+  public:
+
+  // optional string manufacturer = 6;
+  bool has_manufacturer() const;
+  private:
+  bool _internal_has_manufacturer() const;
+  public:
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_NODISCARD std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // optional string device = 7;
+  bool has_device() const;
+  private:
+  bool _internal_has_device() const;
+  public:
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // optional string osBuildNumber = 8;
+  bool has_osbuildnumber() const;
+  private:
+  bool _internal_has_osbuildnumber() const;
+  public:
+  void clear_osbuildnumber();
+  const std::string& osbuildnumber() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_osbuildnumber(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_osbuildnumber();
+  PROTOBUF_NODISCARD std::string* release_osbuildnumber();
+  void set_allocated_osbuildnumber(std::string* osbuildnumber);
+  private:
+  const std::string& _internal_osbuildnumber() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_osbuildnumber(const std::string& value);
+  std::string* _internal_mutable_osbuildnumber();
+  public:
+
+  // optional string phoneId = 9;
+  bool has_phoneid() const;
+  private:
+  bool _internal_has_phoneid() const;
+  public:
+  void clear_phoneid();
+  const std::string& phoneid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_phoneid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_phoneid();
+  PROTOBUF_NODISCARD std::string* release_phoneid();
+  void set_allocated_phoneid(std::string* phoneid);
+  private:
+  const std::string& _internal_phoneid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phoneid(const std::string& value);
+  std::string* _internal_mutable_phoneid();
+  public:
+
+  // optional string localeLanguageIso6391 = 11;
+  bool has_localelanguageiso6391() const;
+  private:
+  bool _internal_has_localelanguageiso6391() const;
+  public:
+  void clear_localelanguageiso6391();
+  const std::string& localelanguageiso6391() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localelanguageiso6391(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localelanguageiso6391();
+  PROTOBUF_NODISCARD std::string* release_localelanguageiso6391();
+  void set_allocated_localelanguageiso6391(std::string* localelanguageiso6391);
+  private:
+  const std::string& _internal_localelanguageiso6391() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localelanguageiso6391(const std::string& value);
+  std::string* _internal_mutable_localelanguageiso6391();
+  public:
+
+  // optional string localeCountryIso31661Alpha2 = 12;
+  bool has_localecountryiso31661alpha2() const;
+  private:
+  bool _internal_has_localecountryiso31661alpha2() const;
+  public:
+  void clear_localecountryiso31661alpha2();
+  const std::string& localecountryiso31661alpha2() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localecountryiso31661alpha2();
+  PROTOBUF_NODISCARD std::string* release_localecountryiso31661alpha2();
+  void set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2);
+  private:
+  const std::string& _internal_localecountryiso31661alpha2() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localecountryiso31661alpha2(const std::string& value);
+  std::string* _internal_mutable_localecountryiso31661alpha2();
+  public:
+
+  // optional string deviceBoard = 13;
+  bool has_deviceboard() const;
+  private:
+  bool _internal_has_deviceboard() const;
+  public:
+  void clear_deviceboard();
+  const std::string& deviceboard() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_deviceboard(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_deviceboard();
+  PROTOBUF_NODISCARD std::string* release_deviceboard();
+  void set_allocated_deviceboard(std::string* deviceboard);
+  private:
+  const std::string& _internal_deviceboard() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceboard(const std::string& value);
+  std::string* _internal_mutable_deviceboard();
+  public:
+
+  // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
+  bool has_appversion() const;
+  private:
+  bool _internal_has_appversion() const;
+  public:
+  void clear_appversion();
+  const ::proto::ClientPayload_UserAgent_AppVersion& appversion() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent_AppVersion* release_appversion();
+  ::proto::ClientPayload_UserAgent_AppVersion* mutable_appversion();
+  void set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion);
+  private:
+  const ::proto::ClientPayload_UserAgent_AppVersion& _internal_appversion() const;
+  ::proto::ClientPayload_UserAgent_AppVersion* _internal_mutable_appversion();
+  public:
+  void unsafe_arena_set_allocated_appversion(
+      ::proto::ClientPayload_UserAgent_AppVersion* appversion);
+  ::proto::ClientPayload_UserAgent_AppVersion* unsafe_arena_release_appversion();
+
+  // optional .proto.ClientPayload.UserAgent.Platform platform = 1;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  ::proto::ClientPayload_UserAgent_Platform platform() const;
+  void set_platform(::proto::ClientPayload_UserAgent_Platform value);
+  private:
+  ::proto::ClientPayload_UserAgent_Platform _internal_platform() const;
+  void _internal_set_platform(::proto::ClientPayload_UserAgent_Platform value);
+  public:
+
+  // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
+  bool has_releasechannel() const;
+  private:
+  bool _internal_has_releasechannel() const;
+  public:
+  void clear_releasechannel();
+  ::proto::ClientPayload_UserAgent_ReleaseChannel releasechannel() const;
+  void set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value);
+  private:
+  ::proto::ClientPayload_UserAgent_ReleaseChannel _internal_releasechannel() const;
+  void _internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mcc_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnc_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osversion_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osbuildnumber_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phoneid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localelanguageiso6391_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localecountryiso31661alpha2_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceboard_;
+    ::proto::ClientPayload_UserAgent_AppVersion* appversion_;
+    int platform_;
+    int releasechannel_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_WebInfo_WebdPayload final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo.WebdPayload) */ {
+ public:
+  inline ClientPayload_WebInfo_WebdPayload() : ClientPayload_WebInfo_WebdPayload(nullptr) {}
+  ~ClientPayload_WebInfo_WebdPayload() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from);
+  ClientPayload_WebInfo_WebdPayload(ClientPayload_WebInfo_WebdPayload&& from) noexcept
+    : ClientPayload_WebInfo_WebdPayload() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_WebInfo_WebdPayload& operator=(const ClientPayload_WebInfo_WebdPayload& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_WebInfo_WebdPayload& operator=(ClientPayload_WebInfo_WebdPayload&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_WebInfo_WebdPayload& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_WebInfo_WebdPayload* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_WebInfo_WebdPayload*>(
+               &_ClientPayload_WebInfo_WebdPayload_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(ClientPayload_WebInfo_WebdPayload& a, ClientPayload_WebInfo_WebdPayload& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_WebInfo_WebdPayload* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_WebInfo_WebdPayload* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_WebInfo_WebdPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_WebInfo_WebdPayload>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_WebInfo_WebdPayload& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_WebInfo_WebdPayload& from) {
+    ClientPayload_WebInfo_WebdPayload::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_WebInfo_WebdPayload* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.WebInfo.WebdPayload";
+  }
+  protected:
+  explicit ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDocumentTypesFieldNumber = 10,
+    kFeaturesFieldNumber = 11,
+    kUsesParticipantInKeyFieldNumber = 1,
+    kSupportsStarredMessagesFieldNumber = 2,
+    kSupportsDocumentMessagesFieldNumber = 3,
+    kSupportsUrlMessagesFieldNumber = 4,
+    kSupportsMediaRetryFieldNumber = 5,
+    kSupportsE2EImageFieldNumber = 6,
+    kSupportsE2EVideoFieldNumber = 7,
+    kSupportsE2EAudioFieldNumber = 8,
+    kSupportsE2EDocumentFieldNumber = 9,
+  };
+  // optional string documentTypes = 10;
+  bool has_documenttypes() const;
+  private:
+  bool _internal_has_documenttypes() const;
+  public:
+  void clear_documenttypes();
+  const std::string& documenttypes() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_documenttypes(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_documenttypes();
+  PROTOBUF_NODISCARD std::string* release_documenttypes();
+  void set_allocated_documenttypes(std::string* documenttypes);
+  private:
+  const std::string& _internal_documenttypes() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_documenttypes(const std::string& value);
+  std::string* _internal_mutable_documenttypes();
+  public:
+
+  // optional bytes features = 11;
+  bool has_features() const;
+  private:
+  bool _internal_has_features() const;
+  public:
+  void clear_features();
+  const std::string& features() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_features(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_features();
+  PROTOBUF_NODISCARD std::string* release_features();
+  void set_allocated_features(std::string* features);
+  private:
+  const std::string& _internal_features() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_features(const std::string& value);
+  std::string* _internal_mutable_features();
+  public:
+
+  // optional bool usesParticipantInKey = 1;
+  bool has_usesparticipantinkey() const;
+  private:
+  bool _internal_has_usesparticipantinkey() const;
+  public:
+  void clear_usesparticipantinkey();
+  bool usesparticipantinkey() const;
+  void set_usesparticipantinkey(bool value);
+  private:
+  bool _internal_usesparticipantinkey() const;
+  void _internal_set_usesparticipantinkey(bool value);
+  public:
+
+  // optional bool supportsStarredMessages = 2;
+  bool has_supportsstarredmessages() const;
+  private:
+  bool _internal_has_supportsstarredmessages() const;
+  public:
+  void clear_supportsstarredmessages();
+  bool supportsstarredmessages() const;
+  void set_supportsstarredmessages(bool value);
+  private:
+  bool _internal_supportsstarredmessages() const;
+  void _internal_set_supportsstarredmessages(bool value);
+  public:
+
+  // optional bool supportsDocumentMessages = 3;
+  bool has_supportsdocumentmessages() const;
+  private:
+  bool _internal_has_supportsdocumentmessages() const;
+  public:
+  void clear_supportsdocumentmessages();
+  bool supportsdocumentmessages() const;
+  void set_supportsdocumentmessages(bool value);
+  private:
+  bool _internal_supportsdocumentmessages() const;
+  void _internal_set_supportsdocumentmessages(bool value);
+  public:
+
+  // optional bool supportsUrlMessages = 4;
+  bool has_supportsurlmessages() const;
+  private:
+  bool _internal_has_supportsurlmessages() const;
+  public:
+  void clear_supportsurlmessages();
+  bool supportsurlmessages() const;
+  void set_supportsurlmessages(bool value);
+  private:
+  bool _internal_supportsurlmessages() const;
+  void _internal_set_supportsurlmessages(bool value);
+  public:
+
+  // optional bool supportsMediaRetry = 5;
+  bool has_supportsmediaretry() const;
+  private:
+  bool _internal_has_supportsmediaretry() const;
+  public:
+  void clear_supportsmediaretry();
+  bool supportsmediaretry() const;
+  void set_supportsmediaretry(bool value);
+  private:
+  bool _internal_supportsmediaretry() const;
+  void _internal_set_supportsmediaretry(bool value);
+  public:
+
+  // optional bool supportsE2EImage = 6;
+  bool has_supportse2eimage() const;
+  private:
+  bool _internal_has_supportse2eimage() const;
+  public:
+  void clear_supportse2eimage();
+  bool supportse2eimage() const;
+  void set_supportse2eimage(bool value);
+  private:
+  bool _internal_supportse2eimage() const;
+  void _internal_set_supportse2eimage(bool value);
+  public:
+
+  // optional bool supportsE2EVideo = 7;
+  bool has_supportse2evideo() const;
+  private:
+  bool _internal_has_supportse2evideo() const;
+  public:
+  void clear_supportse2evideo();
+  bool supportse2evideo() const;
+  void set_supportse2evideo(bool value);
+  private:
+  bool _internal_supportse2evideo() const;
+  void _internal_set_supportse2evideo(bool value);
+  public:
+
+  // optional bool supportsE2EAudio = 8;
+  bool has_supportse2eaudio() const;
+  private:
+  bool _internal_has_supportse2eaudio() const;
+  public:
+  void clear_supportse2eaudio();
+  bool supportse2eaudio() const;
+  void set_supportse2eaudio(bool value);
+  private:
+  bool _internal_supportse2eaudio() const;
+  void _internal_set_supportse2eaudio(bool value);
+  public:
+
+  // optional bool supportsE2EDocument = 9;
+  bool has_supportse2edocument() const;
+  private:
+  bool _internal_has_supportse2edocument() const;
+  public:
+  void clear_supportse2edocument();
+  bool supportse2edocument() const;
+  void set_supportse2edocument(bool value);
+  private:
+  bool _internal_supportse2edocument() const;
+  void _internal_set_supportse2edocument(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo.WebdPayload)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr documenttypes_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr features_;
+    bool usesparticipantinkey_;
+    bool supportsstarredmessages_;
+    bool supportsdocumentmessages_;
+    bool supportsurlmessages_;
+    bool supportsmediaretry_;
+    bool supportse2eimage_;
+    bool supportse2evideo_;
+    bool supportse2eaudio_;
+    bool supportse2edocument_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload_WebInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo) */ {
+ public:
+  inline ClientPayload_WebInfo() : ClientPayload_WebInfo(nullptr) {}
+  ~ClientPayload_WebInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload_WebInfo(const ClientPayload_WebInfo& from);
+  ClientPayload_WebInfo(ClientPayload_WebInfo&& from) noexcept
+    : ClientPayload_WebInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload_WebInfo& operator=(const ClientPayload_WebInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload_WebInfo& operator=(ClientPayload_WebInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload_WebInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload_WebInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload_WebInfo*>(
+               &_ClientPayload_WebInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(ClientPayload_WebInfo& a, ClientPayload_WebInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload_WebInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload_WebInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload_WebInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload_WebInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload_WebInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload_WebInfo& from) {
+    ClientPayload_WebInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload_WebInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload.WebInfo";
+  }
+  protected:
+  explicit ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPayload_WebInfo_WebdPayload WebdPayload;
+
+  typedef ClientPayload_WebInfo_WebSubPlatform WebSubPlatform;
+  static constexpr WebSubPlatform WEB_BROWSER =
+    ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER;
+  static constexpr WebSubPlatform APP_STORE =
+    ClientPayload_WebInfo_WebSubPlatform_APP_STORE;
+  static constexpr WebSubPlatform WIN_STORE =
+    ClientPayload_WebInfo_WebSubPlatform_WIN_STORE;
+  static constexpr WebSubPlatform DARWIN =
+    ClientPayload_WebInfo_WebSubPlatform_DARWIN;
+  static constexpr WebSubPlatform WINDA =
+    ClientPayload_WebInfo_WebSubPlatform_WINDA;
+  static inline bool WebSubPlatform_IsValid(int value) {
+    return ClientPayload_WebInfo_WebSubPlatform_IsValid(value);
+  }
+  static constexpr WebSubPlatform WebSubPlatform_MIN =
+    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN;
+  static constexpr WebSubPlatform WebSubPlatform_MAX =
+    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX;
+  static constexpr int WebSubPlatform_ARRAYSIZE =
+    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  WebSubPlatform_descriptor() {
+    return ClientPayload_WebInfo_WebSubPlatform_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& WebSubPlatform_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, WebSubPlatform>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function WebSubPlatform_Name.");
+    return ClientPayload_WebInfo_WebSubPlatform_Name(enum_t_value);
+  }
+  static inline bool WebSubPlatform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      WebSubPlatform* value) {
+    return ClientPayload_WebInfo_WebSubPlatform_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRefTokenFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kWebdPayloadFieldNumber = 3,
+    kWebSubPlatformFieldNumber = 4,
+  };
+  // optional string refToken = 1;
+  bool has_reftoken() const;
+  private:
+  bool _internal_has_reftoken() const;
+  public:
+  void clear_reftoken();
+  const std::string& reftoken() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_reftoken(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_reftoken();
+  PROTOBUF_NODISCARD std::string* release_reftoken();
+  void set_allocated_reftoken(std::string* reftoken);
+  private:
+  const std::string& _internal_reftoken() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_reftoken(const std::string& value);
+  std::string* _internal_mutable_reftoken();
+  public:
+
+  // optional string version = 2;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
+  bool has_webdpayload() const;
+  private:
+  bool _internal_has_webdpayload() const;
+  public:
+  void clear_webdpayload();
+  const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo_WebdPayload* release_webdpayload();
+  ::proto::ClientPayload_WebInfo_WebdPayload* mutable_webdpayload();
+  void set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload);
+  private:
+  const ::proto::ClientPayload_WebInfo_WebdPayload& _internal_webdpayload() const;
+  ::proto::ClientPayload_WebInfo_WebdPayload* _internal_mutable_webdpayload();
+  public:
+  void unsafe_arena_set_allocated_webdpayload(
+      ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload);
+  ::proto::ClientPayload_WebInfo_WebdPayload* unsafe_arena_release_webdpayload();
+
+  // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
+  bool has_websubplatform() const;
+  private:
+  bool _internal_has_websubplatform() const;
+  public:
+  void clear_websubplatform();
+  ::proto::ClientPayload_WebInfo_WebSubPlatform websubplatform() const;
+  void set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value);
+  private:
+  ::proto::ClientPayload_WebInfo_WebSubPlatform _internal_websubplatform() const;
+  void _internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reftoken_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+    ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload_;
+    int websubplatform_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPayload final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload) */ {
+ public:
+  inline ClientPayload() : ClientPayload(nullptr) {}
+  ~ClientPayload() override;
+  explicit PROTOBUF_CONSTEXPR ClientPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPayload(const ClientPayload& from);
+  ClientPayload(ClientPayload&& from) noexcept
+    : ClientPayload() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPayload& operator=(const ClientPayload& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPayload& operator=(ClientPayload&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientPayload& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPayload* internal_default_instance() {
+    return reinterpret_cast<const ClientPayload*>(
+               &_ClientPayload_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(ClientPayload& a, ClientPayload& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPayload* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPayload* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPayload>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientPayload& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ClientPayload& from) {
+    ClientPayload::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientPayload* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ClientPayload";
+  }
+  protected:
+  explicit ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPayload_DNSSource DNSSource;
+  typedef ClientPayload_DevicePairingRegistrationData DevicePairingRegistrationData;
+  typedef ClientPayload_UserAgent UserAgent;
+  typedef ClientPayload_WebInfo WebInfo;
+
+  typedef ClientPayload_ConnectReason ConnectReason;
+  static constexpr ConnectReason PUSH =
+    ClientPayload_ConnectReason_PUSH;
+  static constexpr ConnectReason USER_ACTIVATED =
+    ClientPayload_ConnectReason_USER_ACTIVATED;
+  static constexpr ConnectReason SCHEDULED =
+    ClientPayload_ConnectReason_SCHEDULED;
+  static constexpr ConnectReason ERROR_RECONNECT =
+    ClientPayload_ConnectReason_ERROR_RECONNECT;
+  static constexpr ConnectReason NETWORK_SWITCH =
+    ClientPayload_ConnectReason_NETWORK_SWITCH;
+  static constexpr ConnectReason PING_RECONNECT =
+    ClientPayload_ConnectReason_PING_RECONNECT;
+  static inline bool ConnectReason_IsValid(int value) {
+    return ClientPayload_ConnectReason_IsValid(value);
+  }
+  static constexpr ConnectReason ConnectReason_MIN =
+    ClientPayload_ConnectReason_ConnectReason_MIN;
+  static constexpr ConnectReason ConnectReason_MAX =
+    ClientPayload_ConnectReason_ConnectReason_MAX;
+  static constexpr int ConnectReason_ARRAYSIZE =
+    ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ConnectReason_descriptor() {
+    return ClientPayload_ConnectReason_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ConnectReason_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ConnectReason>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ConnectReason_Name.");
+    return ClientPayload_ConnectReason_Name(enum_t_value);
+  }
+  static inline bool ConnectReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ConnectReason* value) {
+    return ClientPayload_ConnectReason_Parse(name, value);
+  }
+
+  typedef ClientPayload_ConnectType ConnectType;
+  static constexpr ConnectType CELLULAR_UNKNOWN =
+    ClientPayload_ConnectType_CELLULAR_UNKNOWN;
+  static constexpr ConnectType WIFI_UNKNOWN =
+    ClientPayload_ConnectType_WIFI_UNKNOWN;
+  static constexpr ConnectType CELLULAR_EDGE =
+    ClientPayload_ConnectType_CELLULAR_EDGE;
+  static constexpr ConnectType CELLULAR_IDEN =
+    ClientPayload_ConnectType_CELLULAR_IDEN;
+  static constexpr ConnectType CELLULAR_UMTS =
+    ClientPayload_ConnectType_CELLULAR_UMTS;
+  static constexpr ConnectType CELLULAR_EVDO =
+    ClientPayload_ConnectType_CELLULAR_EVDO;
+  static constexpr ConnectType CELLULAR_GPRS =
+    ClientPayload_ConnectType_CELLULAR_GPRS;
+  static constexpr ConnectType CELLULAR_HSDPA =
+    ClientPayload_ConnectType_CELLULAR_HSDPA;
+  static constexpr ConnectType CELLULAR_HSUPA =
+    ClientPayload_ConnectType_CELLULAR_HSUPA;
+  static constexpr ConnectType CELLULAR_HSPA =
+    ClientPayload_ConnectType_CELLULAR_HSPA;
+  static constexpr ConnectType CELLULAR_CDMA =
+    ClientPayload_ConnectType_CELLULAR_CDMA;
+  static constexpr ConnectType CELLULAR_1XRTT =
+    ClientPayload_ConnectType_CELLULAR_1XRTT;
+  static constexpr ConnectType CELLULAR_EHRPD =
+    ClientPayload_ConnectType_CELLULAR_EHRPD;
+  static constexpr ConnectType CELLULAR_LTE =
+    ClientPayload_ConnectType_CELLULAR_LTE;
+  static constexpr ConnectType CELLULAR_HSPAP =
+    ClientPayload_ConnectType_CELLULAR_HSPAP;
+  static inline bool ConnectType_IsValid(int value) {
+    return ClientPayload_ConnectType_IsValid(value);
+  }
+  static constexpr ConnectType ConnectType_MIN =
+    ClientPayload_ConnectType_ConnectType_MIN;
+  static constexpr ConnectType ConnectType_MAX =
+    ClientPayload_ConnectType_ConnectType_MAX;
+  static constexpr int ConnectType_ARRAYSIZE =
+    ClientPayload_ConnectType_ConnectType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ConnectType_descriptor() {
+    return ClientPayload_ConnectType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ConnectType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ConnectType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ConnectType_Name.");
+    return ClientPayload_ConnectType_Name(enum_t_value);
+  }
+  static inline bool ConnectType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ConnectType* value) {
+    return ClientPayload_ConnectType_Parse(name, value);
+  }
+
+  typedef ClientPayload_IOSAppExtension IOSAppExtension;
+  static constexpr IOSAppExtension SHARE_EXTENSION =
+    ClientPayload_IOSAppExtension_SHARE_EXTENSION;
+  static constexpr IOSAppExtension SERVICE_EXTENSION =
+    ClientPayload_IOSAppExtension_SERVICE_EXTENSION;
+  static constexpr IOSAppExtension INTENTS_EXTENSION =
+    ClientPayload_IOSAppExtension_INTENTS_EXTENSION;
+  static inline bool IOSAppExtension_IsValid(int value) {
+    return ClientPayload_IOSAppExtension_IsValid(value);
+  }
+  static constexpr IOSAppExtension IOSAppExtension_MIN =
+    ClientPayload_IOSAppExtension_IOSAppExtension_MIN;
+  static constexpr IOSAppExtension IOSAppExtension_MAX =
+    ClientPayload_IOSAppExtension_IOSAppExtension_MAX;
+  static constexpr int IOSAppExtension_ARRAYSIZE =
+    ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  IOSAppExtension_descriptor() {
+    return ClientPayload_IOSAppExtension_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& IOSAppExtension_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, IOSAppExtension>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function IOSAppExtension_Name.");
+    return ClientPayload_IOSAppExtension_Name(enum_t_value);
+  }
+  static inline bool IOSAppExtension_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      IOSAppExtension* value) {
+    return ClientPayload_IOSAppExtension_Parse(name, value);
+  }
+
+  typedef ClientPayload_Product Product;
+  static constexpr Product WHATSAPP =
+    ClientPayload_Product_WHATSAPP;
+  static constexpr Product MESSENGER =
+    ClientPayload_Product_MESSENGER;
+  static inline bool Product_IsValid(int value) {
+    return ClientPayload_Product_IsValid(value);
+  }
+  static constexpr Product Product_MIN =
+    ClientPayload_Product_Product_MIN;
+  static constexpr Product Product_MAX =
+    ClientPayload_Product_Product_MAX;
+  static constexpr int Product_ARRAYSIZE =
+    ClientPayload_Product_Product_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Product_descriptor() {
+    return ClientPayload_Product_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Product_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Product>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Product_Name.");
+    return ClientPayload_Product_Name(enum_t_value);
+  }
+  static inline bool Product_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Product* value) {
+    return ClientPayload_Product_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShardsFieldNumber = 14,
+    kPushNameFieldNumber = 7,
+    kFbCatFieldNumber = 21,
+    kFbUserAgentFieldNumber = 22,
+    kFbDeviceIdFieldNumber = 32,
+    kPaddingBytesFieldNumber = 34,
+    kUserAgentFieldNumber = 5,
+    kWebInfoFieldNumber = 6,
+    kDnsSourceFieldNumber = 15,
+    kDevicePairingDataFieldNumber = 19,
+    kUsernameFieldNumber = 1,
+    kSessionIdFieldNumber = 9,
+    kConnectTypeFieldNumber = 12,
+    kConnectReasonFieldNumber = 13,
+    kConnectAttemptCountFieldNumber = 16,
+    kPassiveFieldNumber = 3,
+    kShortConnectFieldNumber = 10,
+    kOcFieldNumber = 23,
+    kPullFieldNumber = 33,
+    kDeviceFieldNumber = 18,
+    kProductFieldNumber = 20,
+    kLcFieldNumber = 24,
+    kFbAppIdFieldNumber = 31,
+    kIosAppExtensionFieldNumber = 30,
+  };
+  // repeated int32 shards = 14;
+  int shards_size() const;
+  private:
+  int _internal_shards_size() const;
+  public:
+  void clear_shards();
+  private:
+  int32_t _internal_shards(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_shards() const;
+  void _internal_add_shards(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_shards();
+  public:
+  int32_t shards(int index) const;
+  void set_shards(int index, int32_t value);
+  void add_shards(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      shards() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_shards();
+
+  // optional string pushName = 7;
+  bool has_pushname() const;
+  private:
+  bool _internal_has_pushname() const;
+  public:
+  void clear_pushname();
+  const std::string& pushname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pushname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pushname();
+  PROTOBUF_NODISCARD std::string* release_pushname();
+  void set_allocated_pushname(std::string* pushname);
+  private:
+  const std::string& _internal_pushname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
+  std::string* _internal_mutable_pushname();
+  public:
+
+  // optional bytes fbCat = 21;
+  bool has_fbcat() const;
+  private:
+  bool _internal_has_fbcat() const;
+  public:
+  void clear_fbcat();
+  const std::string& fbcat() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fbcat(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fbcat();
+  PROTOBUF_NODISCARD std::string* release_fbcat();
+  void set_allocated_fbcat(std::string* fbcat);
+  private:
+  const std::string& _internal_fbcat() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbcat(const std::string& value);
+  std::string* _internal_mutable_fbcat();
+  public:
+
+  // optional bytes fbUserAgent = 22;
+  bool has_fbuseragent() const;
+  private:
+  bool _internal_has_fbuseragent() const;
+  public:
+  void clear_fbuseragent();
+  const std::string& fbuseragent() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fbuseragent(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fbuseragent();
+  PROTOBUF_NODISCARD std::string* release_fbuseragent();
+  void set_allocated_fbuseragent(std::string* fbuseragent);
+  private:
+  const std::string& _internal_fbuseragent() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbuseragent(const std::string& value);
+  std::string* _internal_mutable_fbuseragent();
+  public:
+
+  // optional bytes fbDeviceId = 32;
+  bool has_fbdeviceid() const;
+  private:
+  bool _internal_has_fbdeviceid() const;
+  public:
+  void clear_fbdeviceid();
+  const std::string& fbdeviceid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fbdeviceid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fbdeviceid();
+  PROTOBUF_NODISCARD std::string* release_fbdeviceid();
+  void set_allocated_fbdeviceid(std::string* fbdeviceid);
+  private:
+  const std::string& _internal_fbdeviceid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbdeviceid(const std::string& value);
+  std::string* _internal_mutable_fbdeviceid();
+  public:
+
+  // optional bytes paddingBytes = 34;
+  bool has_paddingbytes() const;
+  private:
+  bool _internal_has_paddingbytes() const;
+  public:
+  void clear_paddingbytes();
+  const std::string& paddingbytes() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_paddingbytes(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_paddingbytes();
+  PROTOBUF_NODISCARD std::string* release_paddingbytes();
+  void set_allocated_paddingbytes(std::string* paddingbytes);
+  private:
+  const std::string& _internal_paddingbytes() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value);
+  std::string* _internal_mutable_paddingbytes();
+  public:
+
+  // optional .proto.ClientPayload.UserAgent userAgent = 5;
+  bool has_useragent() const;
+  private:
+  bool _internal_has_useragent() const;
+  public:
+  void clear_useragent();
+  const ::proto::ClientPayload_UserAgent& useragent() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent* release_useragent();
+  ::proto::ClientPayload_UserAgent* mutable_useragent();
+  void set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent);
+  private:
+  const ::proto::ClientPayload_UserAgent& _internal_useragent() const;
+  ::proto::ClientPayload_UserAgent* _internal_mutable_useragent();
+  public:
+  void unsafe_arena_set_allocated_useragent(
+      ::proto::ClientPayload_UserAgent* useragent);
+  ::proto::ClientPayload_UserAgent* unsafe_arena_release_useragent();
+
+  // optional .proto.ClientPayload.WebInfo webInfo = 6;
+  bool has_webinfo() const;
+  private:
+  bool _internal_has_webinfo() const;
+  public:
+  void clear_webinfo();
+  const ::proto::ClientPayload_WebInfo& webinfo() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo* release_webinfo();
+  ::proto::ClientPayload_WebInfo* mutable_webinfo();
+  void set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo);
+  private:
+  const ::proto::ClientPayload_WebInfo& _internal_webinfo() const;
+  ::proto::ClientPayload_WebInfo* _internal_mutable_webinfo();
+  public:
+  void unsafe_arena_set_allocated_webinfo(
+      ::proto::ClientPayload_WebInfo* webinfo);
+  ::proto::ClientPayload_WebInfo* unsafe_arena_release_webinfo();
+
+  // optional .proto.ClientPayload.DNSSource dnsSource = 15;
+  bool has_dnssource() const;
+  private:
+  bool _internal_has_dnssource() const;
+  public:
+  void clear_dnssource();
+  const ::proto::ClientPayload_DNSSource& dnssource() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_DNSSource* release_dnssource();
+  ::proto::ClientPayload_DNSSource* mutable_dnssource();
+  void set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource);
+  private:
+  const ::proto::ClientPayload_DNSSource& _internal_dnssource() const;
+  ::proto::ClientPayload_DNSSource* _internal_mutable_dnssource();
+  public:
+  void unsafe_arena_set_allocated_dnssource(
+      ::proto::ClientPayload_DNSSource* dnssource);
+  ::proto::ClientPayload_DNSSource* unsafe_arena_release_dnssource();
+
+  // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
+  bool has_devicepairingdata() const;
+  private:
+  bool _internal_has_devicepairingdata() const;
+  public:
+  void clear_devicepairingdata();
+  const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata() const;
+  PROTOBUF_NODISCARD ::proto::ClientPayload_DevicePairingRegistrationData* release_devicepairingdata();
+  ::proto::ClientPayload_DevicePairingRegistrationData* mutable_devicepairingdata();
+  void set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata);
+  private:
+  const ::proto::ClientPayload_DevicePairingRegistrationData& _internal_devicepairingdata() const;
+  ::proto::ClientPayload_DevicePairingRegistrationData* _internal_mutable_devicepairingdata();
+  public:
+  void unsafe_arena_set_allocated_devicepairingdata(
+      ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata);
+  ::proto::ClientPayload_DevicePairingRegistrationData* unsafe_arena_release_devicepairingdata();
+
+  // optional uint64 username = 1;
+  bool has_username() const;
+  private:
+  bool _internal_has_username() const;
+  public:
+  void clear_username();
+  uint64_t username() const;
+  void set_username(uint64_t value);
+  private:
+  uint64_t _internal_username() const;
+  void _internal_set_username(uint64_t value);
+  public:
+
+  // optional sfixed32 sessionId = 9;
+  bool has_sessionid() const;
+  private:
+  bool _internal_has_sessionid() const;
+  public:
+  void clear_sessionid();
+  int32_t sessionid() const;
+  void set_sessionid(int32_t value);
+  private:
+  int32_t _internal_sessionid() const;
+  void _internal_set_sessionid(int32_t value);
+  public:
+
+  // optional .proto.ClientPayload.ConnectType connectType = 12;
+  bool has_connecttype() const;
+  private:
+  bool _internal_has_connecttype() const;
+  public:
+  void clear_connecttype();
+  ::proto::ClientPayload_ConnectType connecttype() const;
+  void set_connecttype(::proto::ClientPayload_ConnectType value);
+  private:
+  ::proto::ClientPayload_ConnectType _internal_connecttype() const;
+  void _internal_set_connecttype(::proto::ClientPayload_ConnectType value);
+  public:
+
+  // optional .proto.ClientPayload.ConnectReason connectReason = 13;
+  bool has_connectreason() const;
+  private:
+  bool _internal_has_connectreason() const;
+  public:
+  void clear_connectreason();
+  ::proto::ClientPayload_ConnectReason connectreason() const;
+  void set_connectreason(::proto::ClientPayload_ConnectReason value);
+  private:
+  ::proto::ClientPayload_ConnectReason _internal_connectreason() const;
+  void _internal_set_connectreason(::proto::ClientPayload_ConnectReason value);
+  public:
+
+  // optional uint32 connectAttemptCount = 16;
+  bool has_connectattemptcount() const;
+  private:
+  bool _internal_has_connectattemptcount() const;
+  public:
+  void clear_connectattemptcount();
+  uint32_t connectattemptcount() const;
+  void set_connectattemptcount(uint32_t value);
+  private:
+  uint32_t _internal_connectattemptcount() const;
+  void _internal_set_connectattemptcount(uint32_t value);
+  public:
+
+  // optional bool passive = 3;
+  bool has_passive() const;
+  private:
+  bool _internal_has_passive() const;
+  public:
+  void clear_passive();
+  bool passive() const;
+  void set_passive(bool value);
+  private:
+  bool _internal_passive() const;
+  void _internal_set_passive(bool value);
+  public:
+
+  // optional bool shortConnect = 10;
+  bool has_shortconnect() const;
+  private:
+  bool _internal_has_shortconnect() const;
+  public:
+  void clear_shortconnect();
+  bool shortconnect() const;
+  void set_shortconnect(bool value);
+  private:
+  bool _internal_shortconnect() const;
+  void _internal_set_shortconnect(bool value);
+  public:
+
+  // optional bool oc = 23;
+  bool has_oc() const;
+  private:
+  bool _internal_has_oc() const;
+  public:
+  void clear_oc();
+  bool oc() const;
+  void set_oc(bool value);
+  private:
+  bool _internal_oc() const;
+  void _internal_set_oc(bool value);
+  public:
+
+  // optional bool pull = 33;
+  bool has_pull() const;
+  private:
+  bool _internal_has_pull() const;
+  public:
+  void clear_pull();
+  bool pull() const;
+  void set_pull(bool value);
+  private:
+  bool _internal_pull() const;
+  void _internal_set_pull(bool value);
+  public:
+
+  // optional uint32 device = 18;
+  bool has_device() const;
+  private:
+  bool _internal_has_device() const;
+  public:
+  void clear_device();
+  uint32_t device() const;
+  void set_device(uint32_t value);
+  private:
+  uint32_t _internal_device() const;
+  void _internal_set_device(uint32_t value);
+  public:
+
+  // optional .proto.ClientPayload.Product product = 20;
+  bool has_product() const;
+  private:
+  bool _internal_has_product() const;
+  public:
+  void clear_product();
+  ::proto::ClientPayload_Product product() const;
+  void set_product(::proto::ClientPayload_Product value);
+  private:
+  ::proto::ClientPayload_Product _internal_product() const;
+  void _internal_set_product(::proto::ClientPayload_Product value);
+  public:
+
+  // optional int32 lc = 24;
+  bool has_lc() const;
+  private:
+  bool _internal_has_lc() const;
+  public:
+  void clear_lc();
+  int32_t lc() const;
+  void set_lc(int32_t value);
+  private:
+  int32_t _internal_lc() const;
+  void _internal_set_lc(int32_t value);
+  public:
+
+  // optional uint64 fbAppId = 31;
+  bool has_fbappid() const;
+  private:
+  bool _internal_has_fbappid() const;
+  public:
+  void clear_fbappid();
+  uint64_t fbappid() const;
+  void set_fbappid(uint64_t value);
+  private:
+  uint64_t _internal_fbappid() const;
+  void _internal_set_fbappid(uint64_t value);
+  public:
+
+  // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
+  bool has_iosappextension() const;
+  private:
+  bool _internal_has_iosappextension() const;
+  public:
+  void clear_iosappextension();
+  ::proto::ClientPayload_IOSAppExtension iosappextension() const;
+  void set_iosappextension(::proto::ClientPayload_IOSAppExtension value);
+  private:
+  ::proto::ClientPayload_IOSAppExtension _internal_iosappextension() const;
+  void _internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ClientPayload)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > shards_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbcat_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbuseragent_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbdeviceid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_;
+    ::proto::ClientPayload_UserAgent* useragent_;
+    ::proto::ClientPayload_WebInfo* webinfo_;
+    ::proto::ClientPayload_DNSSource* dnssource_;
+    ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata_;
+    uint64_t username_;
+    int32_t sessionid_;
+    int connecttype_;
+    int connectreason_;
+    uint32_t connectattemptcount_;
+    bool passive_;
+    bool shortconnect_;
+    bool oc_;
+    bool pull_;
+    uint32_t device_;
+    int product_;
+    int32_t lc_;
+    uint64_t fbappid_;
+    int iosappextension_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContextInfo_AdReplyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.AdReplyInfo) */ {
+ public:
+  inline ContextInfo_AdReplyInfo() : ContextInfo_AdReplyInfo(nullptr) {}
+  ~ContextInfo_AdReplyInfo() override;
+  explicit PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from);
+  ContextInfo_AdReplyInfo(ContextInfo_AdReplyInfo&& from) noexcept
+    : ContextInfo_AdReplyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContextInfo_AdReplyInfo& operator=(const ContextInfo_AdReplyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContextInfo_AdReplyInfo& operator=(ContextInfo_AdReplyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContextInfo_AdReplyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContextInfo_AdReplyInfo* internal_default_instance() {
+    return reinterpret_cast<const ContextInfo_AdReplyInfo*>(
+               &_ContextInfo_AdReplyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(ContextInfo_AdReplyInfo& a, ContextInfo_AdReplyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContextInfo_AdReplyInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContextInfo_AdReplyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ContextInfo_AdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ContextInfo_AdReplyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContextInfo_AdReplyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ContextInfo_AdReplyInfo& from) {
+    ContextInfo_AdReplyInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContextInfo_AdReplyInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ContextInfo.AdReplyInfo";
+  }
+  protected:
+  explicit ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContextInfo_AdReplyInfo_MediaType MediaType;
+  static constexpr MediaType NONE =
+    ContextInfo_AdReplyInfo_MediaType_NONE;
+  static constexpr MediaType IMAGE =
+    ContextInfo_AdReplyInfo_MediaType_IMAGE;
+  static constexpr MediaType VIDEO =
+    ContextInfo_AdReplyInfo_MediaType_VIDEO;
+  static inline bool MediaType_IsValid(int value) {
+    return ContextInfo_AdReplyInfo_MediaType_IsValid(value);
+  }
+  static constexpr MediaType MediaType_MIN =
+    ContextInfo_AdReplyInfo_MediaType_MediaType_MIN;
+  static constexpr MediaType MediaType_MAX =
+    ContextInfo_AdReplyInfo_MediaType_MediaType_MAX;
+  static constexpr int MediaType_ARRAYSIZE =
+    ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MediaType_descriptor() {
+    return ContextInfo_AdReplyInfo_MediaType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MediaType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MediaType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MediaType_Name.");
+    return ContextInfo_AdReplyInfo_MediaType_Name(enum_t_value);
+  }
+  static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MediaType* value) {
+    return ContextInfo_AdReplyInfo_MediaType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAdvertiserNameFieldNumber = 1,
+    kJpegThumbnailFieldNumber = 16,
+    kCaptionFieldNumber = 17,
+    kMediaTypeFieldNumber = 2,
+  };
+  // optional string advertiserName = 1;
+  bool has_advertisername() const;
+  private:
+  bool _internal_has_advertisername() const;
+  public:
+  void clear_advertisername();
+  const std::string& advertisername() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_advertisername(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_advertisername();
+  PROTOBUF_NODISCARD std::string* release_advertisername();
+  void set_allocated_advertisername(std::string* advertisername);
+  private:
+  const std::string& _internal_advertisername() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_advertisername(const std::string& value);
+  std::string* _internal_mutable_advertisername();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional string caption = 17;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
+  bool has_mediatype() const;
+  private:
+  bool _internal_has_mediatype() const;
+  public:
+  void clear_mediatype();
+  ::proto::ContextInfo_AdReplyInfo_MediaType mediatype() const;
+  void set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value);
+  private:
+  ::proto::ContextInfo_AdReplyInfo_MediaType _internal_mediatype() const;
+  void _internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ContextInfo.AdReplyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr advertisername_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    int mediatype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContextInfo_ExternalAdReplyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.ExternalAdReplyInfo) */ {
+ public:
+  inline ContextInfo_ExternalAdReplyInfo() : ContextInfo_ExternalAdReplyInfo(nullptr) {}
+  ~ContextInfo_ExternalAdReplyInfo() override;
+  explicit PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from);
+  ContextInfo_ExternalAdReplyInfo(ContextInfo_ExternalAdReplyInfo&& from) noexcept
+    : ContextInfo_ExternalAdReplyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContextInfo_ExternalAdReplyInfo& operator=(const ContextInfo_ExternalAdReplyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContextInfo_ExternalAdReplyInfo& operator=(ContextInfo_ExternalAdReplyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContextInfo_ExternalAdReplyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContextInfo_ExternalAdReplyInfo* internal_default_instance() {
+    return reinterpret_cast<const ContextInfo_ExternalAdReplyInfo*>(
+               &_ContextInfo_ExternalAdReplyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(ContextInfo_ExternalAdReplyInfo& a, ContextInfo_ExternalAdReplyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContextInfo_ExternalAdReplyInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContextInfo_ExternalAdReplyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ContextInfo_ExternalAdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ContextInfo_ExternalAdReplyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContextInfo_ExternalAdReplyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ContextInfo_ExternalAdReplyInfo& from) {
+    ContextInfo_ExternalAdReplyInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContextInfo_ExternalAdReplyInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ContextInfo.ExternalAdReplyInfo";
+  }
+  protected:
+  explicit ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContextInfo_ExternalAdReplyInfo_MediaType MediaType;
+  static constexpr MediaType NONE =
+    ContextInfo_ExternalAdReplyInfo_MediaType_NONE;
+  static constexpr MediaType IMAGE =
+    ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE;
+  static constexpr MediaType VIDEO =
+    ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO;
+  static inline bool MediaType_IsValid(int value) {
+    return ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value);
+  }
+  static constexpr MediaType MediaType_MIN =
+    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN;
+  static constexpr MediaType MediaType_MAX =
+    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX;
+  static constexpr int MediaType_ARRAYSIZE =
+    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MediaType_descriptor() {
+    return ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MediaType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MediaType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MediaType_Name.");
+    return ContextInfo_ExternalAdReplyInfo_MediaType_Name(enum_t_value);
+  }
+  static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MediaType* value) {
+    return ContextInfo_ExternalAdReplyInfo_MediaType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTitleFieldNumber = 1,
+    kBodyFieldNumber = 2,
+    kThumbnailUrlFieldNumber = 4,
+    kMediaUrlFieldNumber = 5,
+    kThumbnailFieldNumber = 6,
+    kSourceTypeFieldNumber = 7,
+    kSourceIdFieldNumber = 8,
+    kSourceUrlFieldNumber = 9,
+    kMediaTypeFieldNumber = 3,
+    kContainsAutoReplyFieldNumber = 10,
+    kRenderLargerThumbnailFieldNumber = 11,
+    kShowAdAttributionFieldNumber = 12,
+  };
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string body = 2;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // optional string thumbnailUrl = 4;
+  bool has_thumbnailurl() const;
+  private:
+  bool _internal_has_thumbnailurl() const;
+  public:
+  void clear_thumbnailurl();
+  const std::string& thumbnailurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailurl();
+  PROTOBUF_NODISCARD std::string* release_thumbnailurl();
+  void set_allocated_thumbnailurl(std::string* thumbnailurl);
+  private:
+  const std::string& _internal_thumbnailurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailurl(const std::string& value);
+  std::string* _internal_mutable_thumbnailurl();
+  public:
+
+  // optional string mediaUrl = 5;
+  bool has_mediaurl() const;
+  private:
+  bool _internal_has_mediaurl() const;
+  public:
+  void clear_mediaurl();
+  const std::string& mediaurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediaurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediaurl();
+  PROTOBUF_NODISCARD std::string* release_mediaurl();
+  void set_allocated_mediaurl(std::string* mediaurl);
+  private:
+  const std::string& _internal_mediaurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaurl(const std::string& value);
+  std::string* _internal_mutable_mediaurl();
+  public:
+
+  // optional bytes thumbnail = 6;
+  bool has_thumbnail() const;
+  private:
+  bool _internal_has_thumbnail() const;
+  public:
+  void clear_thumbnail();
+  const std::string& thumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnail();
+  PROTOBUF_NODISCARD std::string* release_thumbnail();
+  void set_allocated_thumbnail(std::string* thumbnail);
+  private:
+  const std::string& _internal_thumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value);
+  std::string* _internal_mutable_thumbnail();
+  public:
+
+  // optional string sourceType = 7;
+  bool has_sourcetype() const;
+  private:
+  bool _internal_has_sourcetype() const;
+  public:
+  void clear_sourcetype();
+  const std::string& sourcetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sourcetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sourcetype();
+  PROTOBUF_NODISCARD std::string* release_sourcetype();
+  void set_allocated_sourcetype(std::string* sourcetype);
+  private:
+  const std::string& _internal_sourcetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourcetype(const std::string& value);
+  std::string* _internal_mutable_sourcetype();
+  public:
+
+  // optional string sourceId = 8;
+  bool has_sourceid() const;
+  private:
+  bool _internal_has_sourceid() const;
+  public:
+  void clear_sourceid();
+  const std::string& sourceid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sourceid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sourceid();
+  PROTOBUF_NODISCARD std::string* release_sourceid();
+  void set_allocated_sourceid(std::string* sourceid);
+  private:
+  const std::string& _internal_sourceid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceid(const std::string& value);
+  std::string* _internal_mutable_sourceid();
+  public:
+
+  // optional string sourceUrl = 9;
+  bool has_sourceurl() const;
+  private:
+  bool _internal_has_sourceurl() const;
+  public:
+  void clear_sourceurl();
+  const std::string& sourceurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sourceurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sourceurl();
+  PROTOBUF_NODISCARD std::string* release_sourceurl();
+  void set_allocated_sourceurl(std::string* sourceurl);
+  private:
+  const std::string& _internal_sourceurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceurl(const std::string& value);
+  std::string* _internal_mutable_sourceurl();
+  public:
+
+  // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
+  bool has_mediatype() const;
+  private:
+  bool _internal_has_mediatype() const;
+  public:
+  void clear_mediatype();
+  ::proto::ContextInfo_ExternalAdReplyInfo_MediaType mediatype() const;
+  void set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value);
+  private:
+  ::proto::ContextInfo_ExternalAdReplyInfo_MediaType _internal_mediatype() const;
+  void _internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value);
+  public:
+
+  // optional bool containsAutoReply = 10;
+  bool has_containsautoreply() const;
+  private:
+  bool _internal_has_containsautoreply() const;
+  public:
+  void clear_containsautoreply();
+  bool containsautoreply() const;
+  void set_containsautoreply(bool value);
+  private:
+  bool _internal_containsautoreply() const;
+  void _internal_set_containsautoreply(bool value);
+  public:
+
+  // optional bool renderLargerThumbnail = 11;
+  bool has_renderlargerthumbnail() const;
+  private:
+  bool _internal_has_renderlargerthumbnail() const;
+  public:
+  void clear_renderlargerthumbnail();
+  bool renderlargerthumbnail() const;
+  void set_renderlargerthumbnail(bool value);
+  private:
+  bool _internal_renderlargerthumbnail() const;
+  void _internal_set_renderlargerthumbnail(bool value);
+  public:
+
+  // optional bool showAdAttribution = 12;
+  bool has_showadattribution() const;
+  private:
+  bool _internal_has_showadattribution() const;
+  public:
+  void clear_showadattribution();
+  bool showadattribution() const;
+  void set_showadattribution(bool value);
+  private:
+  bool _internal_showadattribution() const;
+  void _internal_set_showadattribution(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ContextInfo.ExternalAdReplyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailurl_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaurl_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourcetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceurl_;
+    int mediatype_;
+    bool containsautoreply_;
+    bool renderlargerthumbnail_;
+    bool showadattribution_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContextInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo) */ {
+ public:
+  inline ContextInfo() : ContextInfo(nullptr) {}
+  ~ContextInfo() override;
+  explicit PROTOBUF_CONSTEXPR ContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContextInfo(const ContextInfo& from);
+  ContextInfo(ContextInfo&& from) noexcept
+    : ContextInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContextInfo& operator=(const ContextInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContextInfo& operator=(ContextInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContextInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContextInfo* internal_default_instance() {
+    return reinterpret_cast<const ContextInfo*>(
+               &_ContextInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(ContextInfo& a, ContextInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContextInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContextInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ContextInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContextInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ContextInfo& from) {
+    ContextInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContextInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ContextInfo";
+  }
+  protected:
+  explicit ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContextInfo_AdReplyInfo AdReplyInfo;
+  typedef ContextInfo_ExternalAdReplyInfo ExternalAdReplyInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMentionedJidFieldNumber = 15,
+    kStanzaIdFieldNumber = 1,
+    kParticipantFieldNumber = 2,
+    kRemoteJidFieldNumber = 4,
+    kConversionSourceFieldNumber = 18,
+    kConversionDataFieldNumber = 19,
+    kEphemeralSharedSecretFieldNumber = 27,
+    kEntryPointConversionSourceFieldNumber = 29,
+    kEntryPointConversionAppFieldNumber = 30,
+    kGroupSubjectFieldNumber = 34,
+    kParentGroupJidFieldNumber = 35,
+    kQuotedMessageFieldNumber = 3,
+    kQuotedAdFieldNumber = 23,
+    kPlaceholderKeyFieldNumber = 24,
+    kExternalAdReplyFieldNumber = 28,
+    kDisappearingModeFieldNumber = 32,
+    kActionLinkFieldNumber = 33,
+    kConversionDelaySecondsFieldNumber = 20,
+    kForwardingScoreFieldNumber = 21,
+    kIsForwardedFieldNumber = 22,
+    kExpirationFieldNumber = 25,
+    kEphemeralSettingTimestampFieldNumber = 26,
+    kEntryPointConversionDelaySecondsFieldNumber = 31,
+  };
+  // repeated string mentionedJid = 15;
+  int mentionedjid_size() const;
+  private:
+  int _internal_mentionedjid_size() const;
+  public:
+  void clear_mentionedjid();
+  const std::string& mentionedjid(int index) const;
+  std::string* mutable_mentionedjid(int index);
+  void set_mentionedjid(int index, const std::string& value);
+  void set_mentionedjid(int index, std::string&& value);
+  void set_mentionedjid(int index, const char* value);
+  void set_mentionedjid(int index, const char* value, size_t size);
+  std::string* add_mentionedjid();
+  void add_mentionedjid(const std::string& value);
+  void add_mentionedjid(std::string&& value);
+  void add_mentionedjid(const char* value);
+  void add_mentionedjid(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& mentionedjid() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_mentionedjid();
+  private:
+  const std::string& _internal_mentionedjid(int index) const;
+  std::string* _internal_add_mentionedjid();
+  public:
+
+  // optional string stanzaId = 1;
+  bool has_stanzaid() const;
+  private:
+  bool _internal_has_stanzaid() const;
+  public:
+  void clear_stanzaid();
+  const std::string& stanzaid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stanzaid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stanzaid();
+  PROTOBUF_NODISCARD std::string* release_stanzaid();
+  void set_allocated_stanzaid(std::string* stanzaid);
+  private:
+  const std::string& _internal_stanzaid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
+  std::string* _internal_mutable_stanzaid();
+  public:
+
+  // optional string participant = 2;
+  bool has_participant() const;
+  private:
+  bool _internal_has_participant() const;
+  public:
+  void clear_participant();
+  const std::string& participant() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_participant(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_participant();
+  PROTOBUF_NODISCARD std::string* release_participant();
+  void set_allocated_participant(std::string* participant);
+  private:
+  const std::string& _internal_participant() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
+  std::string* _internal_mutable_participant();
+  public:
+
+  // optional string remoteJid = 4;
+  bool has_remotejid() const;
+  private:
+  bool _internal_has_remotejid() const;
+  public:
+  void clear_remotejid();
+  const std::string& remotejid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remotejid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remotejid();
+  PROTOBUF_NODISCARD std::string* release_remotejid();
+  void set_allocated_remotejid(std::string* remotejid);
+  private:
+  const std::string& _internal_remotejid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value);
+  std::string* _internal_mutable_remotejid();
+  public:
+
+  // optional string conversionSource = 18;
+  bool has_conversionsource() const;
+  private:
+  bool _internal_has_conversionsource() const;
+  public:
+  void clear_conversionsource();
+  const std::string& conversionsource() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_conversionsource(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_conversionsource();
+  PROTOBUF_NODISCARD std::string* release_conversionsource();
+  void set_allocated_conversionsource(std::string* conversionsource);
+  private:
+  const std::string& _internal_conversionsource() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value);
+  std::string* _internal_mutable_conversionsource();
+  public:
+
+  // optional bytes conversionData = 19;
+  bool has_conversiondata() const;
+  private:
+  bool _internal_has_conversiondata() const;
+  public:
+  void clear_conversiondata();
+  const std::string& conversiondata() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_conversiondata(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_conversiondata();
+  PROTOBUF_NODISCARD std::string* release_conversiondata();
+  void set_allocated_conversiondata(std::string* conversiondata);
+  private:
+  const std::string& _internal_conversiondata() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value);
+  std::string* _internal_mutable_conversiondata();
+  public:
+
+  // optional bytes ephemeralSharedSecret = 27;
+  bool has_ephemeralsharedsecret() const;
+  private:
+  bool _internal_has_ephemeralsharedsecret() const;
+  public:
+  void clear_ephemeralsharedsecret();
+  const std::string& ephemeralsharedsecret() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ephemeralsharedsecret();
+  PROTOBUF_NODISCARD std::string* release_ephemeralsharedsecret();
+  void set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret);
+  private:
+  const std::string& _internal_ephemeralsharedsecret() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeralsharedsecret(const std::string& value);
+  std::string* _internal_mutable_ephemeralsharedsecret();
+  public:
+
+  // optional string entryPointConversionSource = 29;
+  bool has_entrypointconversionsource() const;
+  private:
+  bool _internal_has_entrypointconversionsource() const;
+  public:
+  void clear_entrypointconversionsource();
+  const std::string& entrypointconversionsource() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_entrypointconversionsource(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_entrypointconversionsource();
+  PROTOBUF_NODISCARD std::string* release_entrypointconversionsource();
+  void set_allocated_entrypointconversionsource(std::string* entrypointconversionsource);
+  private:
+  const std::string& _internal_entrypointconversionsource() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionsource(const std::string& value);
+  std::string* _internal_mutable_entrypointconversionsource();
+  public:
+
+  // optional string entryPointConversionApp = 30;
+  bool has_entrypointconversionapp() const;
+  private:
+  bool _internal_has_entrypointconversionapp() const;
+  public:
+  void clear_entrypointconversionapp();
+  const std::string& entrypointconversionapp() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_entrypointconversionapp(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_entrypointconversionapp();
+  PROTOBUF_NODISCARD std::string* release_entrypointconversionapp();
+  void set_allocated_entrypointconversionapp(std::string* entrypointconversionapp);
+  private:
+  const std::string& _internal_entrypointconversionapp() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionapp(const std::string& value);
+  std::string* _internal_mutable_entrypointconversionapp();
+  public:
+
+  // optional string groupSubject = 34;
+  bool has_groupsubject() const;
+  private:
+  bool _internal_has_groupsubject() const;
+  public:
+  void clear_groupsubject();
+  const std::string& groupsubject() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupsubject(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupsubject();
+  PROTOBUF_NODISCARD std::string* release_groupsubject();
+  void set_allocated_groupsubject(std::string* groupsubject);
+  private:
+  const std::string& _internal_groupsubject() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupsubject(const std::string& value);
+  std::string* _internal_mutable_groupsubject();
+  public:
+
+  // optional string parentGroupJid = 35;
+  bool has_parentgroupjid() const;
+  private:
+  bool _internal_has_parentgroupjid() const;
+  public:
+  void clear_parentgroupjid();
+  const std::string& parentgroupjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_parentgroupjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_parentgroupjid();
+  PROTOBUF_NODISCARD std::string* release_parentgroupjid();
+  void set_allocated_parentgroupjid(std::string* parentgroupjid);
+  private:
+  const std::string& _internal_parentgroupjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupjid(const std::string& value);
+  std::string* _internal_mutable_parentgroupjid();
+  public:
+
+  // optional .proto.Message quotedMessage = 3;
+  bool has_quotedmessage() const;
+  private:
+  bool _internal_has_quotedmessage() const;
+  public:
+  void clear_quotedmessage();
+  const ::proto::Message& quotedmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_quotedmessage();
+  ::proto::Message* mutable_quotedmessage();
+  void set_allocated_quotedmessage(::proto::Message* quotedmessage);
+  private:
+  const ::proto::Message& _internal_quotedmessage() const;
+  ::proto::Message* _internal_mutable_quotedmessage();
+  public:
+  void unsafe_arena_set_allocated_quotedmessage(
+      ::proto::Message* quotedmessage);
+  ::proto::Message* unsafe_arena_release_quotedmessage();
+
+  // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
+  bool has_quotedad() const;
+  private:
+  bool _internal_has_quotedad() const;
+  public:
+  void clear_quotedad();
+  const ::proto::ContextInfo_AdReplyInfo& quotedad() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo_AdReplyInfo* release_quotedad();
+  ::proto::ContextInfo_AdReplyInfo* mutable_quotedad();
+  void set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad);
+  private:
+  const ::proto::ContextInfo_AdReplyInfo& _internal_quotedad() const;
+  ::proto::ContextInfo_AdReplyInfo* _internal_mutable_quotedad();
+  public:
+  void unsafe_arena_set_allocated_quotedad(
+      ::proto::ContextInfo_AdReplyInfo* quotedad);
+  ::proto::ContextInfo_AdReplyInfo* unsafe_arena_release_quotedad();
+
+  // optional .proto.MessageKey placeholderKey = 24;
+  bool has_placeholderkey() const;
+  private:
+  bool _internal_has_placeholderkey() const;
+  public:
+  void clear_placeholderkey();
+  const ::proto::MessageKey& placeholderkey() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_placeholderkey();
+  ::proto::MessageKey* mutable_placeholderkey();
+  void set_allocated_placeholderkey(::proto::MessageKey* placeholderkey);
+  private:
+  const ::proto::MessageKey& _internal_placeholderkey() const;
+  ::proto::MessageKey* _internal_mutable_placeholderkey();
+  public:
+  void unsafe_arena_set_allocated_placeholderkey(
+      ::proto::MessageKey* placeholderkey);
+  ::proto::MessageKey* unsafe_arena_release_placeholderkey();
+
+  // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
+  bool has_externaladreply() const;
+  private:
+  bool _internal_has_externaladreply() const;
+  public:
+  void clear_externaladreply();
+  const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo_ExternalAdReplyInfo* release_externaladreply();
+  ::proto::ContextInfo_ExternalAdReplyInfo* mutable_externaladreply();
+  void set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply);
+  private:
+  const ::proto::ContextInfo_ExternalAdReplyInfo& _internal_externaladreply() const;
+  ::proto::ContextInfo_ExternalAdReplyInfo* _internal_mutable_externaladreply();
+  public:
+  void unsafe_arena_set_allocated_externaladreply(
+      ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply);
+  ::proto::ContextInfo_ExternalAdReplyInfo* unsafe_arena_release_externaladreply();
+
+  // optional .proto.DisappearingMode disappearingMode = 32;
+  bool has_disappearingmode() const;
+  private:
+  bool _internal_has_disappearingmode() const;
+  public:
+  void clear_disappearingmode();
+  const ::proto::DisappearingMode& disappearingmode() const;
+  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
+  ::proto::DisappearingMode* mutable_disappearingmode();
+  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
+  private:
+  const ::proto::DisappearingMode& _internal_disappearingmode() const;
+  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
+  public:
+  void unsafe_arena_set_allocated_disappearingmode(
+      ::proto::DisappearingMode* disappearingmode);
+  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();
+
+  // optional .proto.ActionLink actionLink = 33;
+  bool has_actionlink() const;
+  private:
+  bool _internal_has_actionlink() const;
+  public:
+  void clear_actionlink();
+  const ::proto::ActionLink& actionlink() const;
+  PROTOBUF_NODISCARD ::proto::ActionLink* release_actionlink();
+  ::proto::ActionLink* mutable_actionlink();
+  void set_allocated_actionlink(::proto::ActionLink* actionlink);
+  private:
+  const ::proto::ActionLink& _internal_actionlink() const;
+  ::proto::ActionLink* _internal_mutable_actionlink();
+  public:
+  void unsafe_arena_set_allocated_actionlink(
+      ::proto::ActionLink* actionlink);
+  ::proto::ActionLink* unsafe_arena_release_actionlink();
+
+  // optional uint32 conversionDelaySeconds = 20;
+  bool has_conversiondelayseconds() const;
+  private:
+  bool _internal_has_conversiondelayseconds() const;
+  public:
+  void clear_conversiondelayseconds();
+  uint32_t conversiondelayseconds() const;
+  void set_conversiondelayseconds(uint32_t value);
+  private:
+  uint32_t _internal_conversiondelayseconds() const;
+  void _internal_set_conversiondelayseconds(uint32_t value);
+  public:
+
+  // optional uint32 forwardingScore = 21;
+  bool has_forwardingscore() const;
+  private:
+  bool _internal_has_forwardingscore() const;
+  public:
+  void clear_forwardingscore();
+  uint32_t forwardingscore() const;
+  void set_forwardingscore(uint32_t value);
+  private:
+  uint32_t _internal_forwardingscore() const;
+  void _internal_set_forwardingscore(uint32_t value);
+  public:
+
+  // optional bool isForwarded = 22;
+  bool has_isforwarded() const;
+  private:
+  bool _internal_has_isforwarded() const;
+  public:
+  void clear_isforwarded();
+  bool isforwarded() const;
+  void set_isforwarded(bool value);
+  private:
+  bool _internal_isforwarded() const;
+  void _internal_set_isforwarded(bool value);
+  public:
+
+  // optional uint32 expiration = 25;
+  bool has_expiration() const;
+  private:
+  bool _internal_has_expiration() const;
+  public:
+  void clear_expiration();
+  uint32_t expiration() const;
+  void set_expiration(uint32_t value);
+  private:
+  uint32_t _internal_expiration() const;
+  void _internal_set_expiration(uint32_t value);
+  public:
+
+  // optional int64 ephemeralSettingTimestamp = 26;
+  bool has_ephemeralsettingtimestamp() const;
+  private:
+  bool _internal_has_ephemeralsettingtimestamp() const;
+  public:
+  void clear_ephemeralsettingtimestamp();
+  int64_t ephemeralsettingtimestamp() const;
+  void set_ephemeralsettingtimestamp(int64_t value);
+  private:
+  int64_t _internal_ephemeralsettingtimestamp() const;
+  void _internal_set_ephemeralsettingtimestamp(int64_t value);
+  public:
+
+  // optional uint32 entryPointConversionDelaySeconds = 31;
+  bool has_entrypointconversiondelayseconds() const;
+  private:
+  bool _internal_has_entrypointconversiondelayseconds() const;
+  public:
+  void clear_entrypointconversiondelayseconds();
+  uint32_t entrypointconversiondelayseconds() const;
+  void set_entrypointconversiondelayseconds(uint32_t value);
+  private:
+  uint32_t _internal_entrypointconversiondelayseconds() const;
+  void _internal_set_entrypointconversiondelayseconds(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ContextInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> mentionedjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeralsharedsecret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionsource_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionapp_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupsubject_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupjid_;
+    ::proto::Message* quotedmessage_;
+    ::proto::ContextInfo_AdReplyInfo* quotedad_;
+    ::proto::MessageKey* placeholderkey_;
+    ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply_;
+    ::proto::DisappearingMode* disappearingmode_;
+    ::proto::ActionLink* actionlink_;
+    uint32_t conversiondelayseconds_;
+    uint32_t forwardingscore_;
+    bool isforwarded_;
+    uint32_t expiration_;
+    int64_t ephemeralsettingtimestamp_;
+    uint32_t entrypointconversiondelayseconds_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Conversation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Conversation) */ {
+ public:
+  inline Conversation() : Conversation(nullptr) {}
+  ~Conversation() override;
+  explicit PROTOBUF_CONSTEXPR Conversation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Conversation(const Conversation& from);
+  Conversation(Conversation&& from) noexcept
+    : Conversation() {
+    *this = ::std::move(from);
+  }
+
+  inline Conversation& operator=(const Conversation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Conversation& operator=(Conversation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Conversation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Conversation* internal_default_instance() {
+    return reinterpret_cast<const Conversation*>(
+               &_Conversation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(Conversation& a, Conversation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Conversation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Conversation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Conversation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Conversation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Conversation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Conversation& from) {
+    Conversation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Conversation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Conversation";
+  }
+  protected:
+  explicit Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Conversation_EndOfHistoryTransferType EndOfHistoryTransferType;
+  static constexpr EndOfHistoryTransferType COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY =
+    Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY;
+  static constexpr EndOfHistoryTransferType COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY =
+    Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY;
+  static inline bool EndOfHistoryTransferType_IsValid(int value) {
+    return Conversation_EndOfHistoryTransferType_IsValid(value);
+  }
+  static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MIN =
+    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN;
+  static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MAX =
+    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX;
+  static constexpr int EndOfHistoryTransferType_ARRAYSIZE =
+    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  EndOfHistoryTransferType_descriptor() {
+    return Conversation_EndOfHistoryTransferType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& EndOfHistoryTransferType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, EndOfHistoryTransferType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function EndOfHistoryTransferType_Name.");
+    return Conversation_EndOfHistoryTransferType_Name(enum_t_value);
+  }
+  static inline bool EndOfHistoryTransferType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      EndOfHistoryTransferType* value) {
+    return Conversation_EndOfHistoryTransferType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessagesFieldNumber = 2,
+    kParticipantFieldNumber = 20,
+    kIdFieldNumber = 1,
+    kNewJidFieldNumber = 3,
+    kOldJidFieldNumber = 4,
+    kNameFieldNumber = 13,
+    kPHashFieldNumber = 14,
+    kTcTokenFieldNumber = 21,
+    kContactPrimaryIdentityKeyFieldNumber = 23,
+    kCreatedByFieldNumber = 32,
+    kDescriptionFieldNumber = 33,
+    kParentGroupIdFieldNumber = 37,
+    kDisplayNameFieldNumber = 38,
+    kPnJidFieldNumber = 39,
+    kDisappearingModeFieldNumber = 17,
+    kWallpaperFieldNumber = 26,
+    kLastMsgTimestampFieldNumber = 5,
+    kUnreadCountFieldNumber = 6,
+    kEphemeralExpirationFieldNumber = 9,
+    kEphemeralSettingTimestampFieldNumber = 10,
+    kEndOfHistoryTransferTypeFieldNumber = 11,
+    kReadOnlyFieldNumber = 7,
+    kEndOfHistoryTransferFieldNumber = 8,
+    kNotSpamFieldNumber = 15,
+    kArchivedFieldNumber = 16,
+    kConversationTimestampFieldNumber = 12,
+    kUnreadMentionCountFieldNumber = 18,
+    kPinnedFieldNumber = 24,
+    kTcTokenTimestampFieldNumber = 22,
+    kMuteEndTimeFieldNumber = 25,
+    kMediaVisibilityFieldNumber = 27,
+    kMarkedAsUnreadFieldNumber = 19,
+    kSuspendedFieldNumber = 29,
+    kTerminatedFieldNumber = 30,
+    kSupportFieldNumber = 34,
+    kTcTokenSenderTimestampFieldNumber = 28,
+    kCreatedAtFieldNumber = 31,
+    kIsParentGroupFieldNumber = 35,
+    kIsDefaultSubgroupFieldNumber = 36,
+    kSelfPnExposedFieldNumber = 40,
+  };
+  // repeated .proto.HistorySyncMsg messages = 2;
+  int messages_size() const;
+  private:
+  int _internal_messages_size() const;
+  public:
+  void clear_messages();
+  ::proto::HistorySyncMsg* mutable_messages(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >*
+      mutable_messages();
+  private:
+  const ::proto::HistorySyncMsg& _internal_messages(int index) const;
+  ::proto::HistorySyncMsg* _internal_add_messages();
+  public:
+  const ::proto::HistorySyncMsg& messages(int index) const;
+  ::proto::HistorySyncMsg* add_messages();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >&
+      messages() const;
+
+  // repeated .proto.GroupParticipant participant = 20;
+  int participant_size() const;
+  private:
+  int _internal_participant_size() const;
+  public:
+  void clear_participant();
+  ::proto::GroupParticipant* mutable_participant(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >*
+      mutable_participant();
+  private:
+  const ::proto::GroupParticipant& _internal_participant(int index) const;
+  ::proto::GroupParticipant* _internal_add_participant();
+  public:
+  const ::proto::GroupParticipant& participant(int index) const;
+  ::proto::GroupParticipant* add_participant();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >&
+      participant() const;
+
+  // required string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional string newJid = 3;
+  bool has_newjid() const;
+  private:
+  bool _internal_has_newjid() const;
+  public:
+  void clear_newjid();
+  const std::string& newjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_newjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_newjid();
+  PROTOBUF_NODISCARD std::string* release_newjid();
+  void set_allocated_newjid(std::string* newjid);
+  private:
+  const std::string& _internal_newjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_newjid(const std::string& value);
+  std::string* _internal_mutable_newjid();
+  public:
+
+  // optional string oldJid = 4;
+  bool has_oldjid() const;
+  private:
+  bool _internal_has_oldjid() const;
+  public:
+  void clear_oldjid();
+  const std::string& oldjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oldjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oldjid();
+  PROTOBUF_NODISCARD std::string* release_oldjid();
+  void set_allocated_oldjid(std::string* oldjid);
+  private:
+  const std::string& _internal_oldjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldjid(const std::string& value);
+  std::string* _internal_mutable_oldjid();
+  public:
+
+  // optional string name = 13;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string pHash = 14;
+  bool has_phash() const;
+  private:
+  bool _internal_has_phash() const;
+  public:
+  void clear_phash();
+  const std::string& phash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_phash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_phash();
+  PROTOBUF_NODISCARD std::string* release_phash();
+  void set_allocated_phash(std::string* phash);
+  private:
+  const std::string& _internal_phash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value);
+  std::string* _internal_mutable_phash();
+  public:
+
+  // optional bytes tcToken = 21;
+  bool has_tctoken() const;
+  private:
+  bool _internal_has_tctoken() const;
+  public:
+  void clear_tctoken();
+  const std::string& tctoken() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_tctoken(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_tctoken();
+  PROTOBUF_NODISCARD std::string* release_tctoken();
+  void set_allocated_tctoken(std::string* tctoken);
+  private:
+  const std::string& _internal_tctoken() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tctoken(const std::string& value);
+  std::string* _internal_mutable_tctoken();
+  public:
+
+  // optional bytes contactPrimaryIdentityKey = 23;
+  bool has_contactprimaryidentitykey() const;
+  private:
+  bool _internal_has_contactprimaryidentitykey() const;
+  public:
+  void clear_contactprimaryidentitykey();
+  const std::string& contactprimaryidentitykey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_contactprimaryidentitykey();
+  PROTOBUF_NODISCARD std::string* release_contactprimaryidentitykey();
+  void set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey);
+  private:
+  const std::string& _internal_contactprimaryidentitykey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contactprimaryidentitykey(const std::string& value);
+  std::string* _internal_mutable_contactprimaryidentitykey();
+  public:
+
+  // optional string createdBy = 32;
+  bool has_createdby() const;
+  private:
+  bool _internal_has_createdby() const;
+  public:
+  void clear_createdby();
+  const std::string& createdby() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_createdby(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_createdby();
+  PROTOBUF_NODISCARD std::string* release_createdby();
+  void set_allocated_createdby(std::string* createdby);
+  private:
+  const std::string& _internal_createdby() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_createdby(const std::string& value);
+  std::string* _internal_mutable_createdby();
+  public:
+
+  // optional string description = 33;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string parentGroupId = 37;
+  bool has_parentgroupid() const;
+  private:
+  bool _internal_has_parentgroupid() const;
+  public:
+  void clear_parentgroupid();
+  const std::string& parentgroupid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_parentgroupid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_parentgroupid();
+  PROTOBUF_NODISCARD std::string* release_parentgroupid();
+  void set_allocated_parentgroupid(std::string* parentgroupid);
+  private:
+  const std::string& _internal_parentgroupid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupid(const std::string& value);
+  std::string* _internal_mutable_parentgroupid();
+  public:
+
+  // optional string displayName = 38;
+  bool has_displayname() const;
+  private:
+  bool _internal_has_displayname() const;
+  public:
+  void clear_displayname();
+  const std::string& displayname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displayname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displayname();
+  PROTOBUF_NODISCARD std::string* release_displayname();
+  void set_allocated_displayname(std::string* displayname);
+  private:
+  const std::string& _internal_displayname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value);
+  std::string* _internal_mutable_displayname();
+  public:
+
+  // optional string pnJid = 39;
+  bool has_pnjid() const;
+  private:
+  bool _internal_has_pnjid() const;
+  public:
+  void clear_pnjid();
+  const std::string& pnjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pnjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pnjid();
+  PROTOBUF_NODISCARD std::string* release_pnjid();
+  void set_allocated_pnjid(std::string* pnjid);
+  private:
+  const std::string& _internal_pnjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pnjid(const std::string& value);
+  std::string* _internal_mutable_pnjid();
+  public:
+
+  // optional .proto.DisappearingMode disappearingMode = 17;
+  bool has_disappearingmode() const;
+  private:
+  bool _internal_has_disappearingmode() const;
+  public:
+  void clear_disappearingmode();
+  const ::proto::DisappearingMode& disappearingmode() const;
+  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
+  ::proto::DisappearingMode* mutable_disappearingmode();
+  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
+  private:
+  const ::proto::DisappearingMode& _internal_disappearingmode() const;
+  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
+  public:
+  void unsafe_arena_set_allocated_disappearingmode(
+      ::proto::DisappearingMode* disappearingmode);
+  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();
+
+  // optional .proto.WallpaperSettings wallpaper = 26;
+  bool has_wallpaper() const;
+  private:
+  bool _internal_has_wallpaper() const;
+  public:
+  void clear_wallpaper();
+  const ::proto::WallpaperSettings& wallpaper() const;
+  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_wallpaper();
+  ::proto::WallpaperSettings* mutable_wallpaper();
+  void set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper);
+  private:
+  const ::proto::WallpaperSettings& _internal_wallpaper() const;
+  ::proto::WallpaperSettings* _internal_mutable_wallpaper();
+  public:
+  void unsafe_arena_set_allocated_wallpaper(
+      ::proto::WallpaperSettings* wallpaper);
+  ::proto::WallpaperSettings* unsafe_arena_release_wallpaper();
+
+  // optional uint64 lastMsgTimestamp = 5;
+  bool has_lastmsgtimestamp() const;
+  private:
+  bool _internal_has_lastmsgtimestamp() const;
+  public:
+  void clear_lastmsgtimestamp();
+  uint64_t lastmsgtimestamp() const;
+  void set_lastmsgtimestamp(uint64_t value);
+  private:
+  uint64_t _internal_lastmsgtimestamp() const;
+  void _internal_set_lastmsgtimestamp(uint64_t value);
+  public:
+
+  // optional uint32 unreadCount = 6;
+  bool has_unreadcount() const;
+  private:
+  bool _internal_has_unreadcount() const;
+  public:
+  void clear_unreadcount();
+  uint32_t unreadcount() const;
+  void set_unreadcount(uint32_t value);
+  private:
+  uint32_t _internal_unreadcount() const;
+  void _internal_set_unreadcount(uint32_t value);
+  public:
+
+  // optional uint32 ephemeralExpiration = 9;
+  bool has_ephemeralexpiration() const;
+  private:
+  bool _internal_has_ephemeralexpiration() const;
+  public:
+  void clear_ephemeralexpiration();
+  uint32_t ephemeralexpiration() const;
+  void set_ephemeralexpiration(uint32_t value);
+  private:
+  uint32_t _internal_ephemeralexpiration() const;
+  void _internal_set_ephemeralexpiration(uint32_t value);
+  public:
+
+  // optional int64 ephemeralSettingTimestamp = 10;
+  bool has_ephemeralsettingtimestamp() const;
+  private:
+  bool _internal_has_ephemeralsettingtimestamp() const;
+  public:
+  void clear_ephemeralsettingtimestamp();
+  int64_t ephemeralsettingtimestamp() const;
+  void set_ephemeralsettingtimestamp(int64_t value);
+  private:
+  int64_t _internal_ephemeralsettingtimestamp() const;
+  void _internal_set_ephemeralsettingtimestamp(int64_t value);
+  public:
+
+  // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
+  bool has_endofhistorytransfertype() const;
+  private:
+  bool _internal_has_endofhistorytransfertype() const;
+  public:
+  void clear_endofhistorytransfertype();
+  ::proto::Conversation_EndOfHistoryTransferType endofhistorytransfertype() const;
+  void set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value);
+  private:
+  ::proto::Conversation_EndOfHistoryTransferType _internal_endofhistorytransfertype() const;
+  void _internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value);
+  public:
+
+  // optional bool readOnly = 7;
+  bool has_readonly() const;
+  private:
+  bool _internal_has_readonly() const;
+  public:
+  void clear_readonly();
+  bool readonly() const;
+  void set_readonly(bool value);
+  private:
+  bool _internal_readonly() const;
+  void _internal_set_readonly(bool value);
+  public:
+
+  // optional bool endOfHistoryTransfer = 8;
+  bool has_endofhistorytransfer() const;
+  private:
+  bool _internal_has_endofhistorytransfer() const;
+  public:
+  void clear_endofhistorytransfer();
+  bool endofhistorytransfer() const;
+  void set_endofhistorytransfer(bool value);
+  private:
+  bool _internal_endofhistorytransfer() const;
+  void _internal_set_endofhistorytransfer(bool value);
+  public:
+
+  // optional bool notSpam = 15;
+  bool has_notspam() const;
+  private:
+  bool _internal_has_notspam() const;
+  public:
+  void clear_notspam();
+  bool notspam() const;
+  void set_notspam(bool value);
+  private:
+  bool _internal_notspam() const;
+  void _internal_set_notspam(bool value);
+  public:
+
+  // optional bool archived = 16;
+  bool has_archived() const;
+  private:
+  bool _internal_has_archived() const;
+  public:
+  void clear_archived();
+  bool archived() const;
+  void set_archived(bool value);
+  private:
+  bool _internal_archived() const;
+  void _internal_set_archived(bool value);
+  public:
+
+  // optional uint64 conversationTimestamp = 12;
+  bool has_conversationtimestamp() const;
+  private:
+  bool _internal_has_conversationtimestamp() const;
+  public:
+  void clear_conversationtimestamp();
+  uint64_t conversationtimestamp() const;
+  void set_conversationtimestamp(uint64_t value);
+  private:
+  uint64_t _internal_conversationtimestamp() const;
+  void _internal_set_conversationtimestamp(uint64_t value);
+  public:
+
+  // optional uint32 unreadMentionCount = 18;
+  bool has_unreadmentioncount() const;
+  private:
+  bool _internal_has_unreadmentioncount() const;
+  public:
+  void clear_unreadmentioncount();
+  uint32_t unreadmentioncount() const;
+  void set_unreadmentioncount(uint32_t value);
+  private:
+  uint32_t _internal_unreadmentioncount() const;
+  void _internal_set_unreadmentioncount(uint32_t value);
+  public:
+
+  // optional uint32 pinned = 24;
+  bool has_pinned() const;
+  private:
+  bool _internal_has_pinned() const;
+  public:
+  void clear_pinned();
+  uint32_t pinned() const;
+  void set_pinned(uint32_t value);
+  private:
+  uint32_t _internal_pinned() const;
+  void _internal_set_pinned(uint32_t value);
+  public:
+
+  // optional uint64 tcTokenTimestamp = 22;
+  bool has_tctokentimestamp() const;
+  private:
+  bool _internal_has_tctokentimestamp() const;
+  public:
+  void clear_tctokentimestamp();
+  uint64_t tctokentimestamp() const;
+  void set_tctokentimestamp(uint64_t value);
+  private:
+  uint64_t _internal_tctokentimestamp() const;
+  void _internal_set_tctokentimestamp(uint64_t value);
+  public:
+
+  // optional uint64 muteEndTime = 25;
+  bool has_muteendtime() const;
+  private:
+  bool _internal_has_muteendtime() const;
+  public:
+  void clear_muteendtime();
+  uint64_t muteendtime() const;
+  void set_muteendtime(uint64_t value);
+  private:
+  uint64_t _internal_muteendtime() const;
+  void _internal_set_muteendtime(uint64_t value);
+  public:
+
+  // optional .proto.MediaVisibility mediaVisibility = 27;
+  bool has_mediavisibility() const;
+  private:
+  bool _internal_has_mediavisibility() const;
+  public:
+  void clear_mediavisibility();
+  ::proto::MediaVisibility mediavisibility() const;
+  void set_mediavisibility(::proto::MediaVisibility value);
+  private:
+  ::proto::MediaVisibility _internal_mediavisibility() const;
+  void _internal_set_mediavisibility(::proto::MediaVisibility value);
+  public:
+
+  // optional bool markedAsUnread = 19;
+  bool has_markedasunread() const;
+  private:
+  bool _internal_has_markedasunread() const;
+  public:
+  void clear_markedasunread();
+  bool markedasunread() const;
+  void set_markedasunread(bool value);
+  private:
+  bool _internal_markedasunread() const;
+  void _internal_set_markedasunread(bool value);
+  public:
+
+  // optional bool suspended = 29;
+  bool has_suspended() const;
+  private:
+  bool _internal_has_suspended() const;
+  public:
+  void clear_suspended();
+  bool suspended() const;
+  void set_suspended(bool value);
+  private:
+  bool _internal_suspended() const;
+  void _internal_set_suspended(bool value);
+  public:
+
+  // optional bool terminated = 30;
+  bool has_terminated() const;
+  private:
+  bool _internal_has_terminated() const;
+  public:
+  void clear_terminated();
+  bool terminated() const;
+  void set_terminated(bool value);
+  private:
+  bool _internal_terminated() const;
+  void _internal_set_terminated(bool value);
+  public:
+
+  // optional bool support = 34;
+  bool has_support() const;
+  private:
+  bool _internal_has_support() const;
+  public:
+  void clear_support();
+  bool support() const;
+  void set_support(bool value);
+  private:
+  bool _internal_support() const;
+  void _internal_set_support(bool value);
+  public:
+
+  // optional uint64 tcTokenSenderTimestamp = 28;
+  bool has_tctokensendertimestamp() const;
+  private:
+  bool _internal_has_tctokensendertimestamp() const;
+  public:
+  void clear_tctokensendertimestamp();
+  uint64_t tctokensendertimestamp() const;
+  void set_tctokensendertimestamp(uint64_t value);
+  private:
+  uint64_t _internal_tctokensendertimestamp() const;
+  void _internal_set_tctokensendertimestamp(uint64_t value);
+  public:
+
+  // optional uint64 createdAt = 31;
+  bool has_createdat() const;
+  private:
+  bool _internal_has_createdat() const;
+  public:
+  void clear_createdat();
+  uint64_t createdat() const;
+  void set_createdat(uint64_t value);
+  private:
+  uint64_t _internal_createdat() const;
+  void _internal_set_createdat(uint64_t value);
+  public:
+
+  // optional bool isParentGroup = 35;
+  bool has_isparentgroup() const;
+  private:
+  bool _internal_has_isparentgroup() const;
+  public:
+  void clear_isparentgroup();
+  bool isparentgroup() const;
+  void set_isparentgroup(bool value);
+  private:
+  bool _internal_isparentgroup() const;
+  void _internal_set_isparentgroup(bool value);
+  public:
+
+  // optional bool isDefaultSubgroup = 36;
+  bool has_isdefaultsubgroup() const;
+  private:
+  bool _internal_has_isdefaultsubgroup() const;
+  public:
+  void clear_isdefaultsubgroup();
+  bool isdefaultsubgroup() const;
+  void set_isdefaultsubgroup(bool value);
+  private:
+  bool _internal_isdefaultsubgroup() const;
+  void _internal_set_isdefaultsubgroup(bool value);
+  public:
+
+  // optional bool selfPnExposed = 40;
+  bool has_selfpnexposed() const;
+  private:
+  bool _internal_has_selfpnexposed() const;
+  public:
+  void clear_selfpnexposed();
+  bool selfpnexposed() const;
+  void set_selfpnexposed(bool value);
+  private:
+  bool _internal_selfpnexposed() const;
+  void _internal_set_selfpnexposed(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Conversation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg > messages_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant > participant_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tctoken_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contactprimaryidentitykey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr createdby_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pnjid_;
+    ::proto::DisappearingMode* disappearingmode_;
+    ::proto::WallpaperSettings* wallpaper_;
+    uint64_t lastmsgtimestamp_;
+    uint32_t unreadcount_;
+    uint32_t ephemeralexpiration_;
+    int64_t ephemeralsettingtimestamp_;
+    int endofhistorytransfertype_;
+    bool readonly_;
+    bool endofhistorytransfer_;
+    bool notspam_;
+    bool archived_;
+    uint64_t conversationtimestamp_;
+    uint32_t unreadmentioncount_;
+    uint32_t pinned_;
+    uint64_t tctokentimestamp_;
+    uint64_t muteendtime_;
+    int mediavisibility_;
+    bool markedasunread_;
+    bool suspended_;
+    bool terminated_;
+    bool support_;
+    uint64_t tctokensendertimestamp_;
+    uint64_t createdat_;
+    bool isparentgroup_;
+    bool isdefaultsubgroup_;
+    bool selfpnexposed_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceListMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceListMetadata) */ {
+ public:
+  inline DeviceListMetadata() : DeviceListMetadata(nullptr) {}
+  ~DeviceListMetadata() override;
+  explicit PROTOBUF_CONSTEXPR DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceListMetadata(const DeviceListMetadata& from);
+  DeviceListMetadata(DeviceListMetadata&& from) noexcept
+    : DeviceListMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceListMetadata& operator=(const DeviceListMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceListMetadata& operator=(DeviceListMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceListMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceListMetadata* internal_default_instance() {
+    return reinterpret_cast<const DeviceListMetadata*>(
+               &_DeviceListMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    26;
+
+  friend void swap(DeviceListMetadata& a, DeviceListMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceListMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceListMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceListMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceListMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceListMetadata& from) {
+    DeviceListMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceListMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.DeviceListMetadata";
+  }
+  protected:
+  explicit DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSenderKeyIndexesFieldNumber = 3,
+    kRecipientKeyIndexesFieldNumber = 10,
+    kSenderKeyHashFieldNumber = 1,
+    kRecipientKeyHashFieldNumber = 8,
+    kSenderTimestampFieldNumber = 2,
+    kRecipientTimestampFieldNumber = 9,
+  };
+  // repeated uint32 senderKeyIndexes = 3 [packed = true];
+  int senderkeyindexes_size() const;
+  private:
+  int _internal_senderkeyindexes_size() const;
+  public:
+  void clear_senderkeyindexes();
+  private:
+  uint32_t _internal_senderkeyindexes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_senderkeyindexes() const;
+  void _internal_add_senderkeyindexes(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_senderkeyindexes();
+  public:
+  uint32_t senderkeyindexes(int index) const;
+  void set_senderkeyindexes(int index, uint32_t value);
+  void add_senderkeyindexes(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      senderkeyindexes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_senderkeyindexes();
+
+  // repeated uint32 recipientKeyIndexes = 10 [packed = true];
+  int recipientkeyindexes_size() const;
+  private:
+  int _internal_recipientkeyindexes_size() const;
+  public:
+  void clear_recipientkeyindexes();
+  private:
+  uint32_t _internal_recipientkeyindexes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_recipientkeyindexes() const;
+  void _internal_add_recipientkeyindexes(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_recipientkeyindexes();
+  public:
+  uint32_t recipientkeyindexes(int index) const;
+  void set_recipientkeyindexes(int index, uint32_t value);
+  void add_recipientkeyindexes(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      recipientkeyindexes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_recipientkeyindexes();
+
+  // optional bytes senderKeyHash = 1;
+  bool has_senderkeyhash() const;
+  private:
+  bool _internal_has_senderkeyhash() const;
+  public:
+  void clear_senderkeyhash();
+  const std::string& senderkeyhash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_senderkeyhash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_senderkeyhash();
+  PROTOBUF_NODISCARD std::string* release_senderkeyhash();
+  void set_allocated_senderkeyhash(std::string* senderkeyhash);
+  private:
+  const std::string& _internal_senderkeyhash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderkeyhash(const std::string& value);
+  std::string* _internal_mutable_senderkeyhash();
+  public:
+
+  // optional bytes recipientKeyHash = 8;
+  bool has_recipientkeyhash() const;
+  private:
+  bool _internal_has_recipientkeyhash() const;
+  public:
+  void clear_recipientkeyhash();
+  const std::string& recipientkeyhash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_recipientkeyhash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_recipientkeyhash();
+  PROTOBUF_NODISCARD std::string* release_recipientkeyhash();
+  void set_allocated_recipientkeyhash(std::string* recipientkeyhash);
+  private:
+  const std::string& _internal_recipientkeyhash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientkeyhash(const std::string& value);
+  std::string* _internal_mutable_recipientkeyhash();
+  public:
+
+  // optional uint64 senderTimestamp = 2;
+  bool has_sendertimestamp() const;
+  private:
+  bool _internal_has_sendertimestamp() const;
+  public:
+  void clear_sendertimestamp();
+  uint64_t sendertimestamp() const;
+  void set_sendertimestamp(uint64_t value);
+  private:
+  uint64_t _internal_sendertimestamp() const;
+  void _internal_set_sendertimestamp(uint64_t value);
+  public:
+
+  // optional uint64 recipientTimestamp = 9;
+  bool has_recipienttimestamp() const;
+  private:
+  bool _internal_has_recipienttimestamp() const;
+  public:
+  void clear_recipienttimestamp();
+  uint64_t recipienttimestamp() const;
+  void set_recipienttimestamp(uint64_t value);
+  private:
+  uint64_t _internal_recipienttimestamp() const;
+  void _internal_set_recipienttimestamp(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.DeviceListMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > senderkeyindexes_;
+    mutable std::atomic<int> _senderkeyindexes_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > recipientkeyindexes_;
+    mutable std::atomic<int> _recipientkeyindexes_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderkeyhash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr recipientkeyhash_;
+    uint64_t sendertimestamp_;
+    uint64_t recipienttimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceProps_AppVersion final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps.AppVersion) */ {
+ public:
+  inline DeviceProps_AppVersion() : DeviceProps_AppVersion(nullptr) {}
+  ~DeviceProps_AppVersion() override;
+  explicit PROTOBUF_CONSTEXPR DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceProps_AppVersion(const DeviceProps_AppVersion& from);
+  DeviceProps_AppVersion(DeviceProps_AppVersion&& from) noexcept
+    : DeviceProps_AppVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceProps_AppVersion& operator=(const DeviceProps_AppVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceProps_AppVersion& operator=(DeviceProps_AppVersion&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceProps_AppVersion& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceProps_AppVersion* internal_default_instance() {
+    return reinterpret_cast<const DeviceProps_AppVersion*>(
+               &_DeviceProps_AppVersion_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    27;
+
+  friend void swap(DeviceProps_AppVersion& a, DeviceProps_AppVersion& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceProps_AppVersion* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceProps_AppVersion* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceProps_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceProps_AppVersion>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceProps_AppVersion& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceProps_AppVersion& from) {
+    DeviceProps_AppVersion::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceProps_AppVersion* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.DeviceProps.AppVersion";
+  }
+  protected:
+  explicit DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrimaryFieldNumber = 1,
+    kSecondaryFieldNumber = 2,
+    kTertiaryFieldNumber = 3,
+    kQuaternaryFieldNumber = 4,
+    kQuinaryFieldNumber = 5,
+  };
+  // optional uint32 primary = 1;
+  bool has_primary() const;
+  private:
+  bool _internal_has_primary() const;
+  public:
+  void clear_primary();
+  uint32_t primary() const;
+  void set_primary(uint32_t value);
+  private:
+  uint32_t _internal_primary() const;
+  void _internal_set_primary(uint32_t value);
+  public:
+
+  // optional uint32 secondary = 2;
+  bool has_secondary() const;
+  private:
+  bool _internal_has_secondary() const;
+  public:
+  void clear_secondary();
+  uint32_t secondary() const;
+  void set_secondary(uint32_t value);
+  private:
+  uint32_t _internal_secondary() const;
+  void _internal_set_secondary(uint32_t value);
+  public:
+
+  // optional uint32 tertiary = 3;
+  bool has_tertiary() const;
+  private:
+  bool _internal_has_tertiary() const;
+  public:
+  void clear_tertiary();
+  uint32_t tertiary() const;
+  void set_tertiary(uint32_t value);
+  private:
+  uint32_t _internal_tertiary() const;
+  void _internal_set_tertiary(uint32_t value);
+  public:
+
+  // optional uint32 quaternary = 4;
+  bool has_quaternary() const;
+  private:
+  bool _internal_has_quaternary() const;
+  public:
+  void clear_quaternary();
+  uint32_t quaternary() const;
+  void set_quaternary(uint32_t value);
+  private:
+  uint32_t _internal_quaternary() const;
+  void _internal_set_quaternary(uint32_t value);
+  public:
+
+  // optional uint32 quinary = 5;
+  bool has_quinary() const;
+  private:
+  bool _internal_has_quinary() const;
+  public:
+  void clear_quinary();
+  uint32_t quinary() const;
+  void set_quinary(uint32_t value);
+  private:
+  uint32_t _internal_quinary() const;
+  void _internal_set_quinary(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.DeviceProps.AppVersion)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t primary_;
+    uint32_t secondary_;
+    uint32_t tertiary_;
+    uint32_t quaternary_;
+    uint32_t quinary_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceProps final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps) */ {
+ public:
+  inline DeviceProps() : DeviceProps(nullptr) {}
+  ~DeviceProps() override;
+  explicit PROTOBUF_CONSTEXPR DeviceProps(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceProps(const DeviceProps& from);
+  DeviceProps(DeviceProps&& from) noexcept
+    : DeviceProps() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceProps& operator=(const DeviceProps& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceProps& operator=(DeviceProps&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceProps& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceProps* internal_default_instance() {
+    return reinterpret_cast<const DeviceProps*>(
+               &_DeviceProps_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    28;
+
+  friend void swap(DeviceProps& a, DeviceProps& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceProps* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceProps* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceProps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceProps>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceProps& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceProps& from) {
+    DeviceProps::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceProps* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.DeviceProps";
+  }
+  protected:
+  explicit DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceProps_AppVersion AppVersion;
+
+  typedef DeviceProps_PlatformType PlatformType;
+  static constexpr PlatformType UNKNOWN =
+    DeviceProps_PlatformType_UNKNOWN;
+  static constexpr PlatformType CHROME =
+    DeviceProps_PlatformType_CHROME;
+  static constexpr PlatformType FIREFOX =
+    DeviceProps_PlatformType_FIREFOX;
+  static constexpr PlatformType IE =
+    DeviceProps_PlatformType_IE;
+  static constexpr PlatformType OPERA =
+    DeviceProps_PlatformType_OPERA;
+  static constexpr PlatformType SAFARI =
+    DeviceProps_PlatformType_SAFARI;
+  static constexpr PlatformType EDGE =
+    DeviceProps_PlatformType_EDGE;
+  static constexpr PlatformType DESKTOP =
+    DeviceProps_PlatformType_DESKTOP;
+  static constexpr PlatformType IPAD =
+    DeviceProps_PlatformType_IPAD;
+  static constexpr PlatformType ANDROID_TABLET =
+    DeviceProps_PlatformType_ANDROID_TABLET;
+  static constexpr PlatformType OHANA =
+    DeviceProps_PlatformType_OHANA;
+  static constexpr PlatformType ALOHA =
+    DeviceProps_PlatformType_ALOHA;
+  static constexpr PlatformType CATALINA =
+    DeviceProps_PlatformType_CATALINA;
+  static constexpr PlatformType TCL_TV =
+    DeviceProps_PlatformType_TCL_TV;
+  static inline bool PlatformType_IsValid(int value) {
+    return DeviceProps_PlatformType_IsValid(value);
+  }
+  static constexpr PlatformType PlatformType_MIN =
+    DeviceProps_PlatformType_PlatformType_MIN;
+  static constexpr PlatformType PlatformType_MAX =
+    DeviceProps_PlatformType_PlatformType_MAX;
+  static constexpr int PlatformType_ARRAYSIZE =
+    DeviceProps_PlatformType_PlatformType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  PlatformType_descriptor() {
+    return DeviceProps_PlatformType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& PlatformType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, PlatformType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function PlatformType_Name.");
+    return DeviceProps_PlatformType_Name(enum_t_value);
+  }
+  static inline bool PlatformType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      PlatformType* value) {
+    return DeviceProps_PlatformType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOsFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kPlatformTypeFieldNumber = 3,
+    kRequireFullSyncFieldNumber = 4,
+  };
+  // optional string os = 1;
+  bool has_os() const;
+  private:
+  bool _internal_has_os() const;
+  public:
+  void clear_os();
+  const std::string& os() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_os(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_os();
+  PROTOBUF_NODISCARD std::string* release_os();
+  void set_allocated_os(std::string* os);
+  private:
+  const std::string& _internal_os() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_os(const std::string& value);
+  std::string* _internal_mutable_os();
+  public:
+
+  // optional .proto.DeviceProps.AppVersion version = 2;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const ::proto::DeviceProps_AppVersion& version() const;
+  PROTOBUF_NODISCARD ::proto::DeviceProps_AppVersion* release_version();
+  ::proto::DeviceProps_AppVersion* mutable_version();
+  void set_allocated_version(::proto::DeviceProps_AppVersion* version);
+  private:
+  const ::proto::DeviceProps_AppVersion& _internal_version() const;
+  ::proto::DeviceProps_AppVersion* _internal_mutable_version();
+  public:
+  void unsafe_arena_set_allocated_version(
+      ::proto::DeviceProps_AppVersion* version);
+  ::proto::DeviceProps_AppVersion* unsafe_arena_release_version();
+
+  // optional .proto.DeviceProps.PlatformType platformType = 3;
+  bool has_platformtype() const;
+  private:
+  bool _internal_has_platformtype() const;
+  public:
+  void clear_platformtype();
+  ::proto::DeviceProps_PlatformType platformtype() const;
+  void set_platformtype(::proto::DeviceProps_PlatformType value);
+  private:
+  ::proto::DeviceProps_PlatformType _internal_platformtype() const;
+  void _internal_set_platformtype(::proto::DeviceProps_PlatformType value);
+  public:
+
+  // optional bool requireFullSync = 4;
+  bool has_requirefullsync() const;
+  private:
+  bool _internal_has_requirefullsync() const;
+  public:
+  void clear_requirefullsync();
+  bool requirefullsync() const;
+  void set_requirefullsync(bool value);
+  private:
+  bool _internal_requirefullsync() const;
+  void _internal_set_requirefullsync(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.DeviceProps)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_;
+    ::proto::DeviceProps_AppVersion* version_;
+    int platformtype_;
+    bool requirefullsync_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DisappearingMode final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DisappearingMode) */ {
+ public:
+  inline DisappearingMode() : DisappearingMode(nullptr) {}
+  ~DisappearingMode() override;
+  explicit PROTOBUF_CONSTEXPR DisappearingMode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DisappearingMode(const DisappearingMode& from);
+  DisappearingMode(DisappearingMode&& from) noexcept
+    : DisappearingMode() {
+    *this = ::std::move(from);
+  }
+
+  inline DisappearingMode& operator=(const DisappearingMode& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DisappearingMode& operator=(DisappearingMode&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DisappearingMode& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DisappearingMode* internal_default_instance() {
+    return reinterpret_cast<const DisappearingMode*>(
+               &_DisappearingMode_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    29;
+
+  friend void swap(DisappearingMode& a, DisappearingMode& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DisappearingMode* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DisappearingMode* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DisappearingMode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DisappearingMode>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DisappearingMode& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DisappearingMode& from) {
+    DisappearingMode::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DisappearingMode* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.DisappearingMode";
+  }
+  protected:
+  explicit DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DisappearingMode_Initiator Initiator;
+  static constexpr Initiator CHANGED_IN_CHAT =
+    DisappearingMode_Initiator_CHANGED_IN_CHAT;
+  static constexpr Initiator INITIATED_BY_ME =
+    DisappearingMode_Initiator_INITIATED_BY_ME;
+  static constexpr Initiator INITIATED_BY_OTHER =
+    DisappearingMode_Initiator_INITIATED_BY_OTHER;
+  static inline bool Initiator_IsValid(int value) {
+    return DisappearingMode_Initiator_IsValid(value);
+  }
+  static constexpr Initiator Initiator_MIN =
+    DisappearingMode_Initiator_Initiator_MIN;
+  static constexpr Initiator Initiator_MAX =
+    DisappearingMode_Initiator_Initiator_MAX;
+  static constexpr int Initiator_ARRAYSIZE =
+    DisappearingMode_Initiator_Initiator_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Initiator_descriptor() {
+    return DisappearingMode_Initiator_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Initiator_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Initiator>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Initiator_Name.");
+    return DisappearingMode_Initiator_Name(enum_t_value);
+  }
+  static inline bool Initiator_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Initiator* value) {
+    return DisappearingMode_Initiator_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInitiatorFieldNumber = 1,
+  };
+  // optional .proto.DisappearingMode.Initiator initiator = 1;
+  bool has_initiator() const;
+  private:
+  bool _internal_has_initiator() const;
+  public:
+  void clear_initiator();
+  ::proto::DisappearingMode_Initiator initiator() const;
+  void set_initiator(::proto::DisappearingMode_Initiator value);
+  private:
+  ::proto::DisappearingMode_Initiator _internal_initiator() const;
+  void _internal_set_initiator(::proto::DisappearingMode_Initiator value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.DisappearingMode)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int initiator_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EphemeralSetting final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.EphemeralSetting) */ {
+ public:
+  inline EphemeralSetting() : EphemeralSetting(nullptr) {}
+  ~EphemeralSetting() override;
+  explicit PROTOBUF_CONSTEXPR EphemeralSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EphemeralSetting(const EphemeralSetting& from);
+  EphemeralSetting(EphemeralSetting&& from) noexcept
+    : EphemeralSetting() {
+    *this = ::std::move(from);
+  }
+
+  inline EphemeralSetting& operator=(const EphemeralSetting& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EphemeralSetting& operator=(EphemeralSetting&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EphemeralSetting& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EphemeralSetting* internal_default_instance() {
+    return reinterpret_cast<const EphemeralSetting*>(
+               &_EphemeralSetting_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    30;
+
+  friend void swap(EphemeralSetting& a, EphemeralSetting& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EphemeralSetting* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EphemeralSetting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EphemeralSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EphemeralSetting>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EphemeralSetting& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EphemeralSetting& from) {
+    EphemeralSetting::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EphemeralSetting* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.EphemeralSetting";
+  }
+  protected:
+  explicit EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTimestampFieldNumber = 2,
+    kDurationFieldNumber = 1,
+  };
+  // optional sfixed64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // optional sfixed32 duration = 1;
+  bool has_duration() const;
+  private:
+  bool _internal_has_duration() const;
+  public:
+  void clear_duration();
+  int32_t duration() const;
+  void set_duration(int32_t value);
+  private:
+  int32_t _internal_duration() const;
+  void _internal_set_duration(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.EphemeralSetting)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t timestamp_;
+    int32_t duration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExitCode final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExitCode) */ {
+ public:
+  inline ExitCode() : ExitCode(nullptr) {}
+  ~ExitCode() override;
+  explicit PROTOBUF_CONSTEXPR ExitCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExitCode(const ExitCode& from);
+  ExitCode(ExitCode&& from) noexcept
+    : ExitCode() {
+    *this = ::std::move(from);
+  }
+
+  inline ExitCode& operator=(const ExitCode& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExitCode& operator=(ExitCode&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExitCode& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExitCode* internal_default_instance() {
+    return reinterpret_cast<const ExitCode*>(
+               &_ExitCode_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    31;
+
+  friend void swap(ExitCode& a, ExitCode& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExitCode* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExitCode* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExitCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExitCode>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExitCode& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ExitCode& from) {
+    ExitCode::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExitCode* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ExitCode";
+  }
+  protected:
+  explicit ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 2,
+    kCodeFieldNumber = 1,
+  };
+  // optional string text = 2;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // optional uint64 code = 1;
+  bool has_code() const;
+  private:
+  bool _internal_has_code() const;
+  public:
+  void clear_code();
+  uint64_t code() const;
+  void set_code(uint64_t value);
+  private:
+  uint64_t _internal_code() const;
+  void _internal_set_code(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ExitCode)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+    uint64_t code_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExternalBlobReference final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExternalBlobReference) */ {
+ public:
+  inline ExternalBlobReference() : ExternalBlobReference(nullptr) {}
+  ~ExternalBlobReference() override;
+  explicit PROTOBUF_CONSTEXPR ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExternalBlobReference(const ExternalBlobReference& from);
+  ExternalBlobReference(ExternalBlobReference&& from) noexcept
+    : ExternalBlobReference() {
+    *this = ::std::move(from);
+  }
+
+  inline ExternalBlobReference& operator=(const ExternalBlobReference& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExternalBlobReference& operator=(ExternalBlobReference&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExternalBlobReference& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExternalBlobReference* internal_default_instance() {
+    return reinterpret_cast<const ExternalBlobReference*>(
+               &_ExternalBlobReference_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    32;
+
+  friend void swap(ExternalBlobReference& a, ExternalBlobReference& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExternalBlobReference* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExternalBlobReference* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExternalBlobReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExternalBlobReference>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExternalBlobReference& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ExternalBlobReference& from) {
+    ExternalBlobReference::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExternalBlobReference* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ExternalBlobReference";
+  }
+  protected:
+  explicit ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMediaKeyFieldNumber = 1,
+    kDirectPathFieldNumber = 2,
+    kHandleFieldNumber = 3,
+    kFileSha256FieldNumber = 5,
+    kFileEncSha256FieldNumber = 6,
+    kFileSizeBytesFieldNumber = 4,
+  };
+  // optional bytes mediaKey = 1;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string directPath = 2;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional string handle = 3;
+  bool has_handle() const;
+  private:
+  bool _internal_has_handle() const;
+  public:
+  void clear_handle();
+  const std::string& handle() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_handle(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_handle();
+  PROTOBUF_NODISCARD std::string* release_handle();
+  void set_allocated_handle(std::string* handle);
+  private:
+  const std::string& _internal_handle() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_handle(const std::string& value);
+  std::string* _internal_mutable_handle();
+  public:
+
+  // optional bytes fileSha256 = 5;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes fileEncSha256 = 6;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional uint64 fileSizeBytes = 4;
+  bool has_filesizebytes() const;
+  private:
+  bool _internal_has_filesizebytes() const;
+  public:
+  void clear_filesizebytes();
+  uint64_t filesizebytes() const;
+  void set_filesizebytes(uint64_t value);
+  private:
+  uint64_t _internal_filesizebytes() const;
+  void _internal_set_filesizebytes(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ExternalBlobReference)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handle_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    uint64_t filesizebytes_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GlobalSettings final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GlobalSettings) */ {
+ public:
+  inline GlobalSettings() : GlobalSettings(nullptr) {}
+  ~GlobalSettings() override;
+  explicit PROTOBUF_CONSTEXPR GlobalSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GlobalSettings(const GlobalSettings& from);
+  GlobalSettings(GlobalSettings&& from) noexcept
+    : GlobalSettings() {
+    *this = ::std::move(from);
+  }
+
+  inline GlobalSettings& operator=(const GlobalSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GlobalSettings& operator=(GlobalSettings&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GlobalSettings& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GlobalSettings* internal_default_instance() {
+    return reinterpret_cast<const GlobalSettings*>(
+               &_GlobalSettings_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    33;
+
+  friend void swap(GlobalSettings& a, GlobalSettings& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GlobalSettings* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GlobalSettings* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GlobalSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GlobalSettings>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GlobalSettings& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GlobalSettings& from) {
+    GlobalSettings::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GlobalSettings* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.GlobalSettings";
+  }
+  protected:
+  explicit GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLightThemeWallpaperFieldNumber = 1,
+    kDarkThemeWallpaperFieldNumber = 3,
+    kAutoDownloadWiFiFieldNumber = 4,
+    kAutoDownloadCellularFieldNumber = 5,
+    kAutoDownloadRoamingFieldNumber = 6,
+    kMediaVisibilityFieldNumber = 2,
+    kShowIndividualNotificationsPreviewFieldNumber = 7,
+    kShowGroupNotificationsPreviewFieldNumber = 8,
+    kDisappearingModeTimestampFieldNumber = 10,
+    kDisappearingModeDurationFieldNumber = 9,
+  };
+  // optional .proto.WallpaperSettings lightThemeWallpaper = 1;
+  bool has_lightthemewallpaper() const;
+  private:
+  bool _internal_has_lightthemewallpaper() const;
+  public:
+  void clear_lightthemewallpaper();
+  const ::proto::WallpaperSettings& lightthemewallpaper() const;
+  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_lightthemewallpaper();
+  ::proto::WallpaperSettings* mutable_lightthemewallpaper();
+  void set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper);
+  private:
+  const ::proto::WallpaperSettings& _internal_lightthemewallpaper() const;
+  ::proto::WallpaperSettings* _internal_mutable_lightthemewallpaper();
+  public:
+  void unsafe_arena_set_allocated_lightthemewallpaper(
+      ::proto::WallpaperSettings* lightthemewallpaper);
+  ::proto::WallpaperSettings* unsafe_arena_release_lightthemewallpaper();
+
+  // optional .proto.WallpaperSettings darkThemeWallpaper = 3;
+  bool has_darkthemewallpaper() const;
+  private:
+  bool _internal_has_darkthemewallpaper() const;
+  public:
+  void clear_darkthemewallpaper();
+  const ::proto::WallpaperSettings& darkthemewallpaper() const;
+  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_darkthemewallpaper();
+  ::proto::WallpaperSettings* mutable_darkthemewallpaper();
+  void set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper);
+  private:
+  const ::proto::WallpaperSettings& _internal_darkthemewallpaper() const;
+  ::proto::WallpaperSettings* _internal_mutable_darkthemewallpaper();
+  public:
+  void unsafe_arena_set_allocated_darkthemewallpaper(
+      ::proto::WallpaperSettings* darkthemewallpaper);
+  ::proto::WallpaperSettings* unsafe_arena_release_darkthemewallpaper();
+
+  // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
+  bool has_autodownloadwifi() const;
+  private:
+  bool _internal_has_autodownloadwifi() const;
+  public:
+  void clear_autodownloadwifi();
+  const ::proto::AutoDownloadSettings& autodownloadwifi() const;
+  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadwifi();
+  ::proto::AutoDownloadSettings* mutable_autodownloadwifi();
+  void set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi);
+  private:
+  const ::proto::AutoDownloadSettings& _internal_autodownloadwifi() const;
+  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadwifi();
+  public:
+  void unsafe_arena_set_allocated_autodownloadwifi(
+      ::proto::AutoDownloadSettings* autodownloadwifi);
+  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadwifi();
+
+  // optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
+  bool has_autodownloadcellular() const;
+  private:
+  bool _internal_has_autodownloadcellular() const;
+  public:
+  void clear_autodownloadcellular();
+  const ::proto::AutoDownloadSettings& autodownloadcellular() const;
+  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadcellular();
+  ::proto::AutoDownloadSettings* mutable_autodownloadcellular();
+  void set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular);
+  private:
+  const ::proto::AutoDownloadSettings& _internal_autodownloadcellular() const;
+  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadcellular();
+  public:
+  void unsafe_arena_set_allocated_autodownloadcellular(
+      ::proto::AutoDownloadSettings* autodownloadcellular);
+  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadcellular();
+
+  // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
+  bool has_autodownloadroaming() const;
+  private:
+  bool _internal_has_autodownloadroaming() const;
+  public:
+  void clear_autodownloadroaming();
+  const ::proto::AutoDownloadSettings& autodownloadroaming() const;
+  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadroaming();
+  ::proto::AutoDownloadSettings* mutable_autodownloadroaming();
+  void set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming);
+  private:
+  const ::proto::AutoDownloadSettings& _internal_autodownloadroaming() const;
+  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadroaming();
+  public:
+  void unsafe_arena_set_allocated_autodownloadroaming(
+      ::proto::AutoDownloadSettings* autodownloadroaming);
+  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadroaming();
+
+  // optional .proto.MediaVisibility mediaVisibility = 2;
+  bool has_mediavisibility() const;
+  private:
+  bool _internal_has_mediavisibility() const;
+  public:
+  void clear_mediavisibility();
+  ::proto::MediaVisibility mediavisibility() const;
+  void set_mediavisibility(::proto::MediaVisibility value);
+  private:
+  ::proto::MediaVisibility _internal_mediavisibility() const;
+  void _internal_set_mediavisibility(::proto::MediaVisibility value);
+  public:
+
+  // optional bool showIndividualNotificationsPreview = 7;
+  bool has_showindividualnotificationspreview() const;
+  private:
+  bool _internal_has_showindividualnotificationspreview() const;
+  public:
+  void clear_showindividualnotificationspreview();
+  bool showindividualnotificationspreview() const;
+  void set_showindividualnotificationspreview(bool value);
+  private:
+  bool _internal_showindividualnotificationspreview() const;
+  void _internal_set_showindividualnotificationspreview(bool value);
+  public:
+
+  // optional bool showGroupNotificationsPreview = 8;
+  bool has_showgroupnotificationspreview() const;
+  private:
+  bool _internal_has_showgroupnotificationspreview() const;
+  public:
+  void clear_showgroupnotificationspreview();
+  bool showgroupnotificationspreview() const;
+  void set_showgroupnotificationspreview(bool value);
+  private:
+  bool _internal_showgroupnotificationspreview() const;
+  void _internal_set_showgroupnotificationspreview(bool value);
+  public:
+
+  // optional int64 disappearingModeTimestamp = 10;
+  bool has_disappearingmodetimestamp() const;
+  private:
+  bool _internal_has_disappearingmodetimestamp() const;
+  public:
+  void clear_disappearingmodetimestamp();
+  int64_t disappearingmodetimestamp() const;
+  void set_disappearingmodetimestamp(int64_t value);
+  private:
+  int64_t _internal_disappearingmodetimestamp() const;
+  void _internal_set_disappearingmodetimestamp(int64_t value);
+  public:
+
+  // optional int32 disappearingModeDuration = 9;
+  bool has_disappearingmodeduration() const;
+  private:
+  bool _internal_has_disappearingmodeduration() const;
+  public:
+  void clear_disappearingmodeduration();
+  int32_t disappearingmodeduration() const;
+  void set_disappearingmodeduration(int32_t value);
+  private:
+  int32_t _internal_disappearingmodeduration() const;
+  void _internal_set_disappearingmodeduration(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.GlobalSettings)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::WallpaperSettings* lightthemewallpaper_;
+    ::proto::WallpaperSettings* darkthemewallpaper_;
+    ::proto::AutoDownloadSettings* autodownloadwifi_;
+    ::proto::AutoDownloadSettings* autodownloadcellular_;
+    ::proto::AutoDownloadSettings* autodownloadroaming_;
+    int mediavisibility_;
+    bool showindividualnotificationspreview_;
+    bool showgroupnotificationspreview_;
+    int64_t disappearingmodetimestamp_;
+    int32_t disappearingmodeduration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GroupParticipant final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GroupParticipant) */ {
+ public:
+  inline GroupParticipant() : GroupParticipant(nullptr) {}
+  ~GroupParticipant() override;
+  explicit PROTOBUF_CONSTEXPR GroupParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GroupParticipant(const GroupParticipant& from);
+  GroupParticipant(GroupParticipant&& from) noexcept
+    : GroupParticipant() {
+    *this = ::std::move(from);
+  }
+
+  inline GroupParticipant& operator=(const GroupParticipant& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GroupParticipant& operator=(GroupParticipant&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GroupParticipant& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GroupParticipant* internal_default_instance() {
+    return reinterpret_cast<const GroupParticipant*>(
+               &_GroupParticipant_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    34;
+
+  friend void swap(GroupParticipant& a, GroupParticipant& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GroupParticipant* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GroupParticipant* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GroupParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GroupParticipant>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GroupParticipant& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GroupParticipant& from) {
+    GroupParticipant::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GroupParticipant* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.GroupParticipant";
+  }
+  protected:
+  explicit GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef GroupParticipant_Rank Rank;
+  static constexpr Rank REGULAR =
+    GroupParticipant_Rank_REGULAR;
+  static constexpr Rank ADMIN =
+    GroupParticipant_Rank_ADMIN;
+  static constexpr Rank SUPERADMIN =
+    GroupParticipant_Rank_SUPERADMIN;
+  static inline bool Rank_IsValid(int value) {
+    return GroupParticipant_Rank_IsValid(value);
+  }
+  static constexpr Rank Rank_MIN =
+    GroupParticipant_Rank_Rank_MIN;
+  static constexpr Rank Rank_MAX =
+    GroupParticipant_Rank_Rank_MAX;
+  static constexpr int Rank_ARRAYSIZE =
+    GroupParticipant_Rank_Rank_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Rank_descriptor() {
+    return GroupParticipant_Rank_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Rank_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Rank>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Rank_Name.");
+    return GroupParticipant_Rank_Name(enum_t_value);
+  }
+  static inline bool Rank_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Rank* value) {
+    return GroupParticipant_Rank_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUserJidFieldNumber = 1,
+    kRankFieldNumber = 2,
+  };
+  // required string userJid = 1;
+  bool has_userjid() const;
+  private:
+  bool _internal_has_userjid() const;
+  public:
+  void clear_userjid();
+  const std::string& userjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_userjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_userjid();
+  PROTOBUF_NODISCARD std::string* release_userjid();
+  void set_allocated_userjid(std::string* userjid);
+  private:
+  const std::string& _internal_userjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
+  std::string* _internal_mutable_userjid();
+  public:
+
+  // optional .proto.GroupParticipant.Rank rank = 2;
+  bool has_rank() const;
+  private:
+  bool _internal_has_rank() const;
+  public:
+  void clear_rank();
+  ::proto::GroupParticipant_Rank rank() const;
+  void set_rank(::proto::GroupParticipant_Rank value);
+  private:
+  ::proto::GroupParticipant_Rank _internal_rank() const;
+  void _internal_set_rank(::proto::GroupParticipant_Rank value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.GroupParticipant)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_;
+    int rank_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HandshakeMessage_ClientFinish final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientFinish) */ {
+ public:
+  inline HandshakeMessage_ClientFinish() : HandshakeMessage_ClientFinish(nullptr) {}
+  ~HandshakeMessage_ClientFinish() override;
+  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from);
+  HandshakeMessage_ClientFinish(HandshakeMessage_ClientFinish&& from) noexcept
+    : HandshakeMessage_ClientFinish() {
+    *this = ::std::move(from);
+  }
+
+  inline HandshakeMessage_ClientFinish& operator=(const HandshakeMessage_ClientFinish& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HandshakeMessage_ClientFinish& operator=(HandshakeMessage_ClientFinish&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HandshakeMessage_ClientFinish& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HandshakeMessage_ClientFinish* internal_default_instance() {
+    return reinterpret_cast<const HandshakeMessage_ClientFinish*>(
+               &_HandshakeMessage_ClientFinish_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    35;
+
+  friend void swap(HandshakeMessage_ClientFinish& a, HandshakeMessage_ClientFinish& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HandshakeMessage_ClientFinish* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HandshakeMessage_ClientFinish* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HandshakeMessage_ClientFinish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HandshakeMessage_ClientFinish>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HandshakeMessage_ClientFinish& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HandshakeMessage_ClientFinish& from) {
+    HandshakeMessage_ClientFinish::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HandshakeMessage_ClientFinish* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HandshakeMessage.ClientFinish";
+  }
+  protected:
+  explicit HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStaticFieldNumber = 1,
+    kPayloadFieldNumber = 2,
+  };
+  // optional bytes static = 1;
+  bool has_static_() const;
+  private:
+  bool _internal_has_static_() const;
+  public:
+  void clear_static_();
+  const std::string& static_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_static_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_static_();
+  PROTOBUF_NODISCARD std::string* release_static_();
+  void set_allocated_static_(std::string* static_);
+  private:
+  const std::string& _internal_static_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
+  std::string* _internal_mutable_static_();
+  public:
+
+  // optional bytes payload = 2;
+  bool has_payload() const;
+  private:
+  bool _internal_has_payload() const;
+  public:
+  void clear_payload();
+  const std::string& payload() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_payload(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_payload();
+  PROTOBUF_NODISCARD std::string* release_payload();
+  void set_allocated_payload(std::string* payload);
+  private:
+  const std::string& _internal_payload() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
+  std::string* _internal_mutable_payload();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientFinish)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HandshakeMessage_ClientHello final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientHello) */ {
+ public:
+  inline HandshakeMessage_ClientHello() : HandshakeMessage_ClientHello(nullptr) {}
+  ~HandshakeMessage_ClientHello() override;
+  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from);
+  HandshakeMessage_ClientHello(HandshakeMessage_ClientHello&& from) noexcept
+    : HandshakeMessage_ClientHello() {
+    *this = ::std::move(from);
+  }
+
+  inline HandshakeMessage_ClientHello& operator=(const HandshakeMessage_ClientHello& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HandshakeMessage_ClientHello& operator=(HandshakeMessage_ClientHello&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HandshakeMessage_ClientHello& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HandshakeMessage_ClientHello* internal_default_instance() {
+    return reinterpret_cast<const HandshakeMessage_ClientHello*>(
+               &_HandshakeMessage_ClientHello_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    36;
+
+  friend void swap(HandshakeMessage_ClientHello& a, HandshakeMessage_ClientHello& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HandshakeMessage_ClientHello* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HandshakeMessage_ClientHello* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HandshakeMessage_ClientHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HandshakeMessage_ClientHello>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HandshakeMessage_ClientHello& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HandshakeMessage_ClientHello& from) {
+    HandshakeMessage_ClientHello::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HandshakeMessage_ClientHello* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HandshakeMessage.ClientHello";
+  }
+  protected:
+  explicit HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEphemeralFieldNumber = 1,
+    kStaticFieldNumber = 2,
+    kPayloadFieldNumber = 3,
+  };
+  // optional bytes ephemeral = 1;
+  bool has_ephemeral() const;
+  private:
+  bool _internal_has_ephemeral() const;
+  public:
+  void clear_ephemeral();
+  const std::string& ephemeral() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ephemeral(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ephemeral();
+  PROTOBUF_NODISCARD std::string* release_ephemeral();
+  void set_allocated_ephemeral(std::string* ephemeral);
+  private:
+  const std::string& _internal_ephemeral() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value);
+  std::string* _internal_mutable_ephemeral();
+  public:
+
+  // optional bytes static = 2;
+  bool has_static_() const;
+  private:
+  bool _internal_has_static_() const;
+  public:
+  void clear_static_();
+  const std::string& static_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_static_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_static_();
+  PROTOBUF_NODISCARD std::string* release_static_();
+  void set_allocated_static_(std::string* static_);
+  private:
+  const std::string& _internal_static_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
+  std::string* _internal_mutable_static_();
+  public:
+
+  // optional bytes payload = 3;
+  bool has_payload() const;
+  private:
+  bool _internal_has_payload() const;
+  public:
+  void clear_payload();
+  const std::string& payload() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_payload(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_payload();
+  PROTOBUF_NODISCARD std::string* release_payload();
+  void set_allocated_payload(std::string* payload);
+  private:
+  const std::string& _internal_payload() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
+  std::string* _internal_mutable_payload();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientHello)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HandshakeMessage_ServerHello final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ServerHello) */ {
+ public:
+  inline HandshakeMessage_ServerHello() : HandshakeMessage_ServerHello(nullptr) {}
+  ~HandshakeMessage_ServerHello() override;
+  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from);
+  HandshakeMessage_ServerHello(HandshakeMessage_ServerHello&& from) noexcept
+    : HandshakeMessage_ServerHello() {
+    *this = ::std::move(from);
+  }
+
+  inline HandshakeMessage_ServerHello& operator=(const HandshakeMessage_ServerHello& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HandshakeMessage_ServerHello& operator=(HandshakeMessage_ServerHello&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HandshakeMessage_ServerHello& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HandshakeMessage_ServerHello* internal_default_instance() {
+    return reinterpret_cast<const HandshakeMessage_ServerHello*>(
+               &_HandshakeMessage_ServerHello_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    37;
+
+  friend void swap(HandshakeMessage_ServerHello& a, HandshakeMessage_ServerHello& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HandshakeMessage_ServerHello* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HandshakeMessage_ServerHello* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HandshakeMessage_ServerHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HandshakeMessage_ServerHello>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HandshakeMessage_ServerHello& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HandshakeMessage_ServerHello& from) {
+    HandshakeMessage_ServerHello::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HandshakeMessage_ServerHello* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HandshakeMessage.ServerHello";
+  }
+  protected:
+  explicit HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEphemeralFieldNumber = 1,
+    kStaticFieldNumber = 2,
+    kPayloadFieldNumber = 3,
+  };
+  // optional bytes ephemeral = 1;
+  bool has_ephemeral() const;
+  private:
+  bool _internal_has_ephemeral() const;
+  public:
+  void clear_ephemeral();
+  const std::string& ephemeral() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ephemeral(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ephemeral();
+  PROTOBUF_NODISCARD std::string* release_ephemeral();
+  void set_allocated_ephemeral(std::string* ephemeral);
+  private:
+  const std::string& _internal_ephemeral() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value);
+  std::string* _internal_mutable_ephemeral();
+  public:
+
+  // optional bytes static = 2;
+  bool has_static_() const;
+  private:
+  bool _internal_has_static_() const;
+  public:
+  void clear_static_();
+  const std::string& static_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_static_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_static_();
+  PROTOBUF_NODISCARD std::string* release_static_();
+  void set_allocated_static_(std::string* static_);
+  private:
+  const std::string& _internal_static_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
+  std::string* _internal_mutable_static_();
+  public:
+
+  // optional bytes payload = 3;
+  bool has_payload() const;
+  private:
+  bool _internal_has_payload() const;
+  public:
+  void clear_payload();
+  const std::string& payload() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_payload(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_payload();
+  PROTOBUF_NODISCARD std::string* release_payload();
+  void set_allocated_payload(std::string* payload);
+  private:
+  const std::string& _internal_payload() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
+  std::string* _internal_mutable_payload();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ServerHello)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HandshakeMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage) */ {
+ public:
+  inline HandshakeMessage() : HandshakeMessage(nullptr) {}
+  ~HandshakeMessage() override;
+  explicit PROTOBUF_CONSTEXPR HandshakeMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HandshakeMessage(const HandshakeMessage& from);
+  HandshakeMessage(HandshakeMessage&& from) noexcept
+    : HandshakeMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline HandshakeMessage& operator=(const HandshakeMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HandshakeMessage& operator=(HandshakeMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HandshakeMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HandshakeMessage* internal_default_instance() {
+    return reinterpret_cast<const HandshakeMessage*>(
+               &_HandshakeMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    38;
+
+  friend void swap(HandshakeMessage& a, HandshakeMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HandshakeMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HandshakeMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HandshakeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HandshakeMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HandshakeMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HandshakeMessage& from) {
+    HandshakeMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HandshakeMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HandshakeMessage";
+  }
+  protected:
+  explicit HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef HandshakeMessage_ClientFinish ClientFinish;
+  typedef HandshakeMessage_ClientHello ClientHello;
+  typedef HandshakeMessage_ServerHello ServerHello;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientHelloFieldNumber = 2,
+    kServerHelloFieldNumber = 3,
+    kClientFinishFieldNumber = 4,
+  };
+  // optional .proto.HandshakeMessage.ClientHello clientHello = 2;
+  bool has_clienthello() const;
+  private:
+  bool _internal_has_clienthello() const;
+  public:
+  void clear_clienthello();
+  const ::proto::HandshakeMessage_ClientHello& clienthello() const;
+  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientHello* release_clienthello();
+  ::proto::HandshakeMessage_ClientHello* mutable_clienthello();
+  void set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello);
+  private:
+  const ::proto::HandshakeMessage_ClientHello& _internal_clienthello() const;
+  ::proto::HandshakeMessage_ClientHello* _internal_mutable_clienthello();
+  public:
+  void unsafe_arena_set_allocated_clienthello(
+      ::proto::HandshakeMessage_ClientHello* clienthello);
+  ::proto::HandshakeMessage_ClientHello* unsafe_arena_release_clienthello();
+
+  // optional .proto.HandshakeMessage.ServerHello serverHello = 3;
+  bool has_serverhello() const;
+  private:
+  bool _internal_has_serverhello() const;
+  public:
+  void clear_serverhello();
+  const ::proto::HandshakeMessage_ServerHello& serverhello() const;
+  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ServerHello* release_serverhello();
+  ::proto::HandshakeMessage_ServerHello* mutable_serverhello();
+  void set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello);
+  private:
+  const ::proto::HandshakeMessage_ServerHello& _internal_serverhello() const;
+  ::proto::HandshakeMessage_ServerHello* _internal_mutable_serverhello();
+  public:
+  void unsafe_arena_set_allocated_serverhello(
+      ::proto::HandshakeMessage_ServerHello* serverhello);
+  ::proto::HandshakeMessage_ServerHello* unsafe_arena_release_serverhello();
+
+  // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
+  bool has_clientfinish() const;
+  private:
+  bool _internal_has_clientfinish() const;
+  public:
+  void clear_clientfinish();
+  const ::proto::HandshakeMessage_ClientFinish& clientfinish() const;
+  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientFinish* release_clientfinish();
+  ::proto::HandshakeMessage_ClientFinish* mutable_clientfinish();
+  void set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish);
+  private:
+  const ::proto::HandshakeMessage_ClientFinish& _internal_clientfinish() const;
+  ::proto::HandshakeMessage_ClientFinish* _internal_mutable_clientfinish();
+  public:
+  void unsafe_arena_set_allocated_clientfinish(
+      ::proto::HandshakeMessage_ClientFinish* clientfinish);
+  ::proto::HandshakeMessage_ClientFinish* unsafe_arena_release_clientfinish();
+
+  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::HandshakeMessage_ClientHello* clienthello_;
+    ::proto::HandshakeMessage_ServerHello* serverhello_;
+    ::proto::HandshakeMessage_ClientFinish* clientfinish_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HistorySync final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySync) */ {
+ public:
+  inline HistorySync() : HistorySync(nullptr) {}
+  ~HistorySync() override;
+  explicit PROTOBUF_CONSTEXPR HistorySync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HistorySync(const HistorySync& from);
+  HistorySync(HistorySync&& from) noexcept
+    : HistorySync() {
+    *this = ::std::move(from);
+  }
+
+  inline HistorySync& operator=(const HistorySync& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HistorySync& operator=(HistorySync&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HistorySync& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HistorySync* internal_default_instance() {
+    return reinterpret_cast<const HistorySync*>(
+               &_HistorySync_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    39;
+
+  friend void swap(HistorySync& a, HistorySync& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HistorySync* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HistorySync* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HistorySync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HistorySync>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HistorySync& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HistorySync& from) {
+    HistorySync::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HistorySync* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HistorySync";
+  }
+  protected:
+  explicit HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef HistorySync_HistorySyncType HistorySyncType;
+  static constexpr HistorySyncType INITIAL_BOOTSTRAP =
+    HistorySync_HistorySyncType_INITIAL_BOOTSTRAP;
+  static constexpr HistorySyncType INITIAL_STATUS_V3 =
+    HistorySync_HistorySyncType_INITIAL_STATUS_V3;
+  static constexpr HistorySyncType FULL =
+    HistorySync_HistorySyncType_FULL;
+  static constexpr HistorySyncType RECENT =
+    HistorySync_HistorySyncType_RECENT;
+  static constexpr HistorySyncType PUSH_NAME =
+    HistorySync_HistorySyncType_PUSH_NAME;
+  static constexpr HistorySyncType UNBLOCKING_DATA =
+    HistorySync_HistorySyncType_UNBLOCKING_DATA;
+  static inline bool HistorySyncType_IsValid(int value) {
+    return HistorySync_HistorySyncType_IsValid(value);
+  }
+  static constexpr HistorySyncType HistorySyncType_MIN =
+    HistorySync_HistorySyncType_HistorySyncType_MIN;
+  static constexpr HistorySyncType HistorySyncType_MAX =
+    HistorySync_HistorySyncType_HistorySyncType_MAX;
+  static constexpr int HistorySyncType_ARRAYSIZE =
+    HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HistorySyncType_descriptor() {
+    return HistorySync_HistorySyncType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HistorySyncType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HistorySyncType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HistorySyncType_Name.");
+    return HistorySync_HistorySyncType_Name(enum_t_value);
+  }
+  static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HistorySyncType* value) {
+    return HistorySync_HistorySyncType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConversationsFieldNumber = 2,
+    kStatusV3MessagesFieldNumber = 3,
+    kPushnamesFieldNumber = 7,
+    kRecentStickersFieldNumber = 11,
+    kPastParticipantsFieldNumber = 12,
+    kThreadIdUserSecretFieldNumber = 9,
+    kGlobalSettingsFieldNumber = 8,
+    kSyncTypeFieldNumber = 1,
+    kChunkOrderFieldNumber = 5,
+    kProgressFieldNumber = 6,
+    kThreadDsTimeframeOffsetFieldNumber = 10,
+  };
+  // repeated .proto.Conversation conversations = 2;
+  int conversations_size() const;
+  private:
+  int _internal_conversations_size() const;
+  public:
+  void clear_conversations();
+  ::proto::Conversation* mutable_conversations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >*
+      mutable_conversations();
+  private:
+  const ::proto::Conversation& _internal_conversations(int index) const;
+  ::proto::Conversation* _internal_add_conversations();
+  public:
+  const ::proto::Conversation& conversations(int index) const;
+  ::proto::Conversation* add_conversations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >&
+      conversations() const;
+
+  // repeated .proto.WebMessageInfo statusV3Messages = 3;
+  int statusv3messages_size() const;
+  private:
+  int _internal_statusv3messages_size() const;
+  public:
+  void clear_statusv3messages();
+  ::proto::WebMessageInfo* mutable_statusv3messages(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
+      mutable_statusv3messages();
+  private:
+  const ::proto::WebMessageInfo& _internal_statusv3messages(int index) const;
+  ::proto::WebMessageInfo* _internal_add_statusv3messages();
+  public:
+  const ::proto::WebMessageInfo& statusv3messages(int index) const;
+  ::proto::WebMessageInfo* add_statusv3messages();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
+      statusv3messages() const;
+
+  // repeated .proto.Pushname pushnames = 7;
+  int pushnames_size() const;
+  private:
+  int _internal_pushnames_size() const;
+  public:
+  void clear_pushnames();
+  ::proto::Pushname* mutable_pushnames(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >*
+      mutable_pushnames();
+  private:
+  const ::proto::Pushname& _internal_pushnames(int index) const;
+  ::proto::Pushname* _internal_add_pushnames();
+  public:
+  const ::proto::Pushname& pushnames(int index) const;
+  ::proto::Pushname* add_pushnames();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >&
+      pushnames() const;
+
+  // repeated .proto.StickerMetadata recentStickers = 11;
+  int recentstickers_size() const;
+  private:
+  int _internal_recentstickers_size() const;
+  public:
+  void clear_recentstickers();
+  ::proto::StickerMetadata* mutable_recentstickers(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >*
+      mutable_recentstickers();
+  private:
+  const ::proto::StickerMetadata& _internal_recentstickers(int index) const;
+  ::proto::StickerMetadata* _internal_add_recentstickers();
+  public:
+  const ::proto::StickerMetadata& recentstickers(int index) const;
+  ::proto::StickerMetadata* add_recentstickers();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >&
+      recentstickers() const;
+
+  // repeated .proto.PastParticipants pastParticipants = 12;
+  int pastparticipants_size() const;
+  private:
+  int _internal_pastparticipants_size() const;
+  public:
+  void clear_pastparticipants();
+  ::proto::PastParticipants* mutable_pastparticipants(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >*
+      mutable_pastparticipants();
+  private:
+  const ::proto::PastParticipants& _internal_pastparticipants(int index) const;
+  ::proto::PastParticipants* _internal_add_pastparticipants();
+  public:
+  const ::proto::PastParticipants& pastparticipants(int index) const;
+  ::proto::PastParticipants* add_pastparticipants();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >&
+      pastparticipants() const;
+
+  // optional bytes threadIdUserSecret = 9;
+  bool has_threadidusersecret() const;
+  private:
+  bool _internal_has_threadidusersecret() const;
+  public:
+  void clear_threadidusersecret();
+  const std::string& threadidusersecret() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_threadidusersecret(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_threadidusersecret();
+  PROTOBUF_NODISCARD std::string* release_threadidusersecret();
+  void set_allocated_threadidusersecret(std::string* threadidusersecret);
+  private:
+  const std::string& _internal_threadidusersecret() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_threadidusersecret(const std::string& value);
+  std::string* _internal_mutable_threadidusersecret();
+  public:
+
+  // optional .proto.GlobalSettings globalSettings = 8;
+  bool has_globalsettings() const;
+  private:
+  bool _internal_has_globalsettings() const;
+  public:
+  void clear_globalsettings();
+  const ::proto::GlobalSettings& globalsettings() const;
+  PROTOBUF_NODISCARD ::proto::GlobalSettings* release_globalsettings();
+  ::proto::GlobalSettings* mutable_globalsettings();
+  void set_allocated_globalsettings(::proto::GlobalSettings* globalsettings);
+  private:
+  const ::proto::GlobalSettings& _internal_globalsettings() const;
+  ::proto::GlobalSettings* _internal_mutable_globalsettings();
+  public:
+  void unsafe_arena_set_allocated_globalsettings(
+      ::proto::GlobalSettings* globalsettings);
+  ::proto::GlobalSettings* unsafe_arena_release_globalsettings();
+
+  // required .proto.HistorySync.HistorySyncType syncType = 1;
+  bool has_synctype() const;
+  private:
+  bool _internal_has_synctype() const;
+  public:
+  void clear_synctype();
+  ::proto::HistorySync_HistorySyncType synctype() const;
+  void set_synctype(::proto::HistorySync_HistorySyncType value);
+  private:
+  ::proto::HistorySync_HistorySyncType _internal_synctype() const;
+  void _internal_set_synctype(::proto::HistorySync_HistorySyncType value);
+  public:
+
+  // optional uint32 chunkOrder = 5;
+  bool has_chunkorder() const;
+  private:
+  bool _internal_has_chunkorder() const;
+  public:
+  void clear_chunkorder();
+  uint32_t chunkorder() const;
+  void set_chunkorder(uint32_t value);
+  private:
+  uint32_t _internal_chunkorder() const;
+  void _internal_set_chunkorder(uint32_t value);
+  public:
+
+  // optional uint32 progress = 6;
+  bool has_progress() const;
+  private:
+  bool _internal_has_progress() const;
+  public:
+  void clear_progress();
+  uint32_t progress() const;
+  void set_progress(uint32_t value);
+  private:
+  uint32_t _internal_progress() const;
+  void _internal_set_progress(uint32_t value);
+  public:
+
+  // optional uint32 threadDsTimeframeOffset = 10;
+  bool has_threaddstimeframeoffset() const;
+  private:
+  bool _internal_has_threaddstimeframeoffset() const;
+  public:
+  void clear_threaddstimeframeoffset();
+  uint32_t threaddstimeframeoffset() const;
+  void set_threaddstimeframeoffset(uint32_t value);
+  private:
+  uint32_t _internal_threaddstimeframeoffset() const;
+  void _internal_set_threaddstimeframeoffset(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HistorySync)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation > conversations_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > statusv3messages_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname > pushnames_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata > recentstickers_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants > pastparticipants_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr threadidusersecret_;
+    ::proto::GlobalSettings* globalsettings_;
+    int synctype_;
+    uint32_t chunkorder_;
+    uint32_t progress_;
+    uint32_t threaddstimeframeoffset_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HistorySyncMsg final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySyncMsg) */ {
+ public:
+  inline HistorySyncMsg() : HistorySyncMsg(nullptr) {}
+  ~HistorySyncMsg() override;
+  explicit PROTOBUF_CONSTEXPR HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HistorySyncMsg(const HistorySyncMsg& from);
+  HistorySyncMsg(HistorySyncMsg&& from) noexcept
+    : HistorySyncMsg() {
+    *this = ::std::move(from);
+  }
+
+  inline HistorySyncMsg& operator=(const HistorySyncMsg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HistorySyncMsg& operator=(HistorySyncMsg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HistorySyncMsg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HistorySyncMsg* internal_default_instance() {
+    return reinterpret_cast<const HistorySyncMsg*>(
+               &_HistorySyncMsg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    40;
+
+  friend void swap(HistorySyncMsg& a, HistorySyncMsg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HistorySyncMsg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HistorySyncMsg* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HistorySyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HistorySyncMsg>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HistorySyncMsg& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HistorySyncMsg& from) {
+    HistorySyncMsg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HistorySyncMsg* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HistorySyncMsg";
+  }
+  protected:
+  explicit HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageFieldNumber = 1,
+    kMsgOrderIdFieldNumber = 2,
+  };
+  // optional .proto.WebMessageInfo message = 1;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const ::proto::WebMessageInfo& message() const;
+  PROTOBUF_NODISCARD ::proto::WebMessageInfo* release_message();
+  ::proto::WebMessageInfo* mutable_message();
+  void set_allocated_message(::proto::WebMessageInfo* message);
+  private:
+  const ::proto::WebMessageInfo& _internal_message() const;
+  ::proto::WebMessageInfo* _internal_mutable_message();
+  public:
+  void unsafe_arena_set_allocated_message(
+      ::proto::WebMessageInfo* message);
+  ::proto::WebMessageInfo* unsafe_arena_release_message();
+
+  // optional uint64 msgOrderId = 2;
+  bool has_msgorderid() const;
+  private:
+  bool _internal_has_msgorderid() const;
+  public:
+  void clear_msgorderid();
+  uint64_t msgorderid() const;
+  void set_msgorderid(uint64_t value);
+  private:
+  uint64_t _internal_msgorderid() const;
+  void _internal_set_msgorderid(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HistorySyncMsg)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::WebMessageInfo* message_;
+    uint64_t msgorderid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HydratedTemplateButton_HydratedCallButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedCallButton) */ {
+ public:
+  inline HydratedTemplateButton_HydratedCallButton() : HydratedTemplateButton_HydratedCallButton(nullptr) {}
+  ~HydratedTemplateButton_HydratedCallButton() override;
+  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from);
+  HydratedTemplateButton_HydratedCallButton(HydratedTemplateButton_HydratedCallButton&& from) noexcept
+    : HydratedTemplateButton_HydratedCallButton() {
+    *this = ::std::move(from);
+  }
+
+  inline HydratedTemplateButton_HydratedCallButton& operator=(const HydratedTemplateButton_HydratedCallButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HydratedTemplateButton_HydratedCallButton& operator=(HydratedTemplateButton_HydratedCallButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HydratedTemplateButton_HydratedCallButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HydratedTemplateButton_HydratedCallButton* internal_default_instance() {
+    return reinterpret_cast<const HydratedTemplateButton_HydratedCallButton*>(
+               &_HydratedTemplateButton_HydratedCallButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    41;
+
+  friend void swap(HydratedTemplateButton_HydratedCallButton& a, HydratedTemplateButton_HydratedCallButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HydratedTemplateButton_HydratedCallButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HydratedTemplateButton_HydratedCallButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HydratedTemplateButton_HydratedCallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HydratedTemplateButton_HydratedCallButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HydratedTemplateButton_HydratedCallButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HydratedTemplateButton_HydratedCallButton& from) {
+    HydratedTemplateButton_HydratedCallButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HydratedTemplateButton_HydratedCallButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HydratedTemplateButton.HydratedCallButton";
+  }
+  protected:
+  explicit HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+    kPhoneNumberFieldNumber = 2,
+  };
+  // optional string displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const std::string& displaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displaytext();
+  PROTOBUF_NODISCARD std::string* release_displaytext();
+  void set_allocated_displaytext(std::string* displaytext);
+  private:
+  const std::string& _internal_displaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
+  std::string* _internal_mutable_displaytext();
+  public:
+
+  // optional string phoneNumber = 2;
+  bool has_phonenumber() const;
+  private:
+  bool _internal_has_phonenumber() const;
+  public:
+  void clear_phonenumber();
+  const std::string& phonenumber() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_phonenumber(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_phonenumber();
+  PROTOBUF_NODISCARD std::string* release_phonenumber();
+  void set_allocated_phonenumber(std::string* phonenumber);
+  private:
+  const std::string& _internal_phonenumber() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phonenumber(const std::string& value);
+  std::string* _internal_mutable_phonenumber();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedCallButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phonenumber_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HydratedTemplateButton_HydratedQuickReplyButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedQuickReplyButton) */ {
+ public:
+  inline HydratedTemplateButton_HydratedQuickReplyButton() : HydratedTemplateButton_HydratedQuickReplyButton(nullptr) {}
+  ~HydratedTemplateButton_HydratedQuickReplyButton() override;
+  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from);
+  HydratedTemplateButton_HydratedQuickReplyButton(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept
+    : HydratedTemplateButton_HydratedQuickReplyButton() {
+    *this = ::std::move(from);
+  }
+
+  inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(const HydratedTemplateButton_HydratedQuickReplyButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HydratedTemplateButton_HydratedQuickReplyButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HydratedTemplateButton_HydratedQuickReplyButton* internal_default_instance() {
+    return reinterpret_cast<const HydratedTemplateButton_HydratedQuickReplyButton*>(
+               &_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    42;
+
+  friend void swap(HydratedTemplateButton_HydratedQuickReplyButton& a, HydratedTemplateButton_HydratedQuickReplyButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HydratedTemplateButton_HydratedQuickReplyButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HydratedTemplateButton_HydratedQuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HydratedTemplateButton_HydratedQuickReplyButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HydratedTemplateButton_HydratedQuickReplyButton& from) {
+    HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HydratedTemplateButton.HydratedQuickReplyButton";
+  }
+  protected:
+  explicit HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+    kIdFieldNumber = 2,
+  };
+  // optional string displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const std::string& displaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displaytext();
+  PROTOBUF_NODISCARD std::string* release_displaytext();
+  void set_allocated_displaytext(std::string* displaytext);
+  private:
+  const std::string& _internal_displaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
+  std::string* _internal_mutable_displaytext();
+  public:
+
+  // optional string id = 2;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedQuickReplyButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HydratedTemplateButton_HydratedURLButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedURLButton) */ {
+ public:
+  inline HydratedTemplateButton_HydratedURLButton() : HydratedTemplateButton_HydratedURLButton(nullptr) {}
+  ~HydratedTemplateButton_HydratedURLButton() override;
+  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from);
+  HydratedTemplateButton_HydratedURLButton(HydratedTemplateButton_HydratedURLButton&& from) noexcept
+    : HydratedTemplateButton_HydratedURLButton() {
+    *this = ::std::move(from);
+  }
+
+  inline HydratedTemplateButton_HydratedURLButton& operator=(const HydratedTemplateButton_HydratedURLButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HydratedTemplateButton_HydratedURLButton& operator=(HydratedTemplateButton_HydratedURLButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HydratedTemplateButton_HydratedURLButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HydratedTemplateButton_HydratedURLButton* internal_default_instance() {
+    return reinterpret_cast<const HydratedTemplateButton_HydratedURLButton*>(
+               &_HydratedTemplateButton_HydratedURLButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    43;
+
+  friend void swap(HydratedTemplateButton_HydratedURLButton& a, HydratedTemplateButton_HydratedURLButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HydratedTemplateButton_HydratedURLButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HydratedTemplateButton_HydratedURLButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HydratedTemplateButton_HydratedURLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HydratedTemplateButton_HydratedURLButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HydratedTemplateButton_HydratedURLButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HydratedTemplateButton_HydratedURLButton& from) {
+    HydratedTemplateButton_HydratedURLButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HydratedTemplateButton_HydratedURLButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HydratedTemplateButton.HydratedURLButton";
+  }
+  protected:
+  explicit HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+    kUrlFieldNumber = 2,
+  };
+  // optional string displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const std::string& displaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displaytext();
+  PROTOBUF_NODISCARD std::string* release_displaytext();
+  void set_allocated_displaytext(std::string* displaytext);
+  private:
+  const std::string& _internal_displaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
+  std::string* _internal_mutable_displaytext();
+  public:
+
+  // optional string url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedURLButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HydratedTemplateButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton) */ {
+ public:
+  inline HydratedTemplateButton() : HydratedTemplateButton(nullptr) {}
+  ~HydratedTemplateButton() override;
+  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HydratedTemplateButton(const HydratedTemplateButton& from);
+  HydratedTemplateButton(HydratedTemplateButton&& from) noexcept
+    : HydratedTemplateButton() {
+    *this = ::std::move(from);
+  }
+
+  inline HydratedTemplateButton& operator=(const HydratedTemplateButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HydratedTemplateButton& operator=(HydratedTemplateButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HydratedTemplateButton& default_instance() {
+    return *internal_default_instance();
+  }
+  enum HydratedButtonCase {
+    kQuickReplyButton = 1,
+    kUrlButton = 2,
+    kCallButton = 3,
+    HYDRATEDBUTTON_NOT_SET = 0,
+  };
+
+  static inline const HydratedTemplateButton* internal_default_instance() {
+    return reinterpret_cast<const HydratedTemplateButton*>(
+               &_HydratedTemplateButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    44;
+
+  friend void swap(HydratedTemplateButton& a, HydratedTemplateButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HydratedTemplateButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HydratedTemplateButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HydratedTemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HydratedTemplateButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HydratedTemplateButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HydratedTemplateButton& from) {
+    HydratedTemplateButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HydratedTemplateButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.HydratedTemplateButton";
+  }
+  protected:
+  explicit HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef HydratedTemplateButton_HydratedCallButton HydratedCallButton;
+  typedef HydratedTemplateButton_HydratedQuickReplyButton HydratedQuickReplyButton;
+  typedef HydratedTemplateButton_HydratedURLButton HydratedURLButton;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndexFieldNumber = 4,
+    kQuickReplyButtonFieldNumber = 1,
+    kUrlButtonFieldNumber = 2,
+    kCallButtonFieldNumber = 3,
+  };
+  // optional uint32 index = 4;
+  bool has_index() const;
+  private:
+  bool _internal_has_index() const;
+  public:
+  void clear_index();
+  uint32_t index() const;
+  void set_index(uint32_t value);
+  private:
+  uint32_t _internal_index() const;
+  void _internal_set_index(uint32_t value);
+  public:
+
+  // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
+  bool has_quickreplybutton() const;
+  private:
+  bool _internal_has_quickreplybutton() const;
+  public:
+  void clear_quickreplybutton();
+  const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton() const;
+  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedQuickReplyButton* release_quickreplybutton();
+  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* mutable_quickreplybutton();
+  void set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton);
+  private:
+  const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& _internal_quickreplybutton() const;
+  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _internal_mutable_quickreplybutton();
+  public:
+  void unsafe_arena_set_allocated_quickreplybutton(
+      ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton);
+  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* unsafe_arena_release_quickreplybutton();
+
+  // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
+  bool has_urlbutton() const;
+  private:
+  bool _internal_has_urlbutton() const;
+  public:
+  void clear_urlbutton();
+  const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton() const;
+  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedURLButton* release_urlbutton();
+  ::proto::HydratedTemplateButton_HydratedURLButton* mutable_urlbutton();
+  void set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton);
+  private:
+  const ::proto::HydratedTemplateButton_HydratedURLButton& _internal_urlbutton() const;
+  ::proto::HydratedTemplateButton_HydratedURLButton* _internal_mutable_urlbutton();
+  public:
+  void unsafe_arena_set_allocated_urlbutton(
+      ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton);
+  ::proto::HydratedTemplateButton_HydratedURLButton* unsafe_arena_release_urlbutton();
+
+  // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
+  bool has_callbutton() const;
+  private:
+  bool _internal_has_callbutton() const;
+  public:
+  void clear_callbutton();
+  const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton() const;
+  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedCallButton* release_callbutton();
+  ::proto::HydratedTemplateButton_HydratedCallButton* mutable_callbutton();
+  void set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton);
+  private:
+  const ::proto::HydratedTemplateButton_HydratedCallButton& _internal_callbutton() const;
+  ::proto::HydratedTemplateButton_HydratedCallButton* _internal_mutable_callbutton();
+  public:
+  void unsafe_arena_set_allocated_callbutton(
+      ::proto::HydratedTemplateButton_HydratedCallButton* callbutton);
+  ::proto::HydratedTemplateButton_HydratedCallButton* unsafe_arena_release_callbutton();
+
+  void clear_hydratedButton();
+  HydratedButtonCase hydratedButton_case() const;
+  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton)
+ private:
+  class _Internal;
+  void set_has_quickreplybutton();
+  void set_has_urlbutton();
+  void set_has_callbutton();
+
+  inline bool has_hydratedButton() const;
+  inline void clear_has_hydratedButton();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t index_;
+    union HydratedButtonUnion {
+      constexpr HydratedButtonUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton_;
+      ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton_;
+      ::proto::HydratedTemplateButton_HydratedCallButton* callbutton_;
+    } hydratedButton_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class IdentityKeyPairStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.IdentityKeyPairStructure) */ {
+ public:
+  inline IdentityKeyPairStructure() : IdentityKeyPairStructure(nullptr) {}
+  ~IdentityKeyPairStructure() override;
+  explicit PROTOBUF_CONSTEXPR IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  IdentityKeyPairStructure(const IdentityKeyPairStructure& from);
+  IdentityKeyPairStructure(IdentityKeyPairStructure&& from) noexcept
+    : IdentityKeyPairStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline IdentityKeyPairStructure& operator=(const IdentityKeyPairStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline IdentityKeyPairStructure& operator=(IdentityKeyPairStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const IdentityKeyPairStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const IdentityKeyPairStructure* internal_default_instance() {
+    return reinterpret_cast<const IdentityKeyPairStructure*>(
+               &_IdentityKeyPairStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    45;
+
+  friend void swap(IdentityKeyPairStructure& a, IdentityKeyPairStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(IdentityKeyPairStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(IdentityKeyPairStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  IdentityKeyPairStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<IdentityKeyPairStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const IdentityKeyPairStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const IdentityKeyPairStructure& from) {
+    IdentityKeyPairStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(IdentityKeyPairStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.IdentityKeyPairStructure";
+  }
+  protected:
+  explicit IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 1,
+    kPrivateKeyFieldNumber = 2,
+  };
+  // optional bytes publicKey = 1;
+  bool has_publickey() const;
+  private:
+  bool _internal_has_publickey() const;
+  public:
+  void clear_publickey();
+  const std::string& publickey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_publickey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_publickey();
+  PROTOBUF_NODISCARD std::string* release_publickey();
+  void set_allocated_publickey(std::string* publickey);
+  private:
+  const std::string& _internal_publickey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value);
+  std::string* _internal_mutable_publickey();
+  public:
+
+  // optional bytes privateKey = 2;
+  bool has_privatekey() const;
+  private:
+  bool _internal_has_privatekey() const;
+  public:
+  void clear_privatekey();
+  const std::string& privatekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_privatekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_privatekey();
+  PROTOBUF_NODISCARD std::string* release_privatekey();
+  void set_allocated_privatekey(std::string* privatekey);
+  private:
+  const std::string& _internal_privatekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value);
+  std::string* _internal_mutable_privatekey();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.IdentityKeyPairStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class InteractiveAnnotation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.InteractiveAnnotation) */ {
+ public:
+  inline InteractiveAnnotation() : InteractiveAnnotation(nullptr) {}
+  ~InteractiveAnnotation() override;
+  explicit PROTOBUF_CONSTEXPR InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  InteractiveAnnotation(const InteractiveAnnotation& from);
+  InteractiveAnnotation(InteractiveAnnotation&& from) noexcept
+    : InteractiveAnnotation() {
+    *this = ::std::move(from);
+  }
+
+  inline InteractiveAnnotation& operator=(const InteractiveAnnotation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline InteractiveAnnotation& operator=(InteractiveAnnotation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const InteractiveAnnotation& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ActionCase {
+    kLocation = 2,
+    ACTION_NOT_SET = 0,
+  };
+
+  static inline const InteractiveAnnotation* internal_default_instance() {
+    return reinterpret_cast<const InteractiveAnnotation*>(
+               &_InteractiveAnnotation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    46;
+
+  friend void swap(InteractiveAnnotation& a, InteractiveAnnotation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(InteractiveAnnotation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(InteractiveAnnotation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  InteractiveAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<InteractiveAnnotation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const InteractiveAnnotation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const InteractiveAnnotation& from) {
+    InteractiveAnnotation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(InteractiveAnnotation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.InteractiveAnnotation";
+  }
+  protected:
+  explicit InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPolygonVerticesFieldNumber = 1,
+    kLocationFieldNumber = 2,
+  };
+  // repeated .proto.Point polygonVertices = 1;
+  int polygonvertices_size() const;
+  private:
+  int _internal_polygonvertices_size() const;
+  public:
+  void clear_polygonvertices();
+  ::proto::Point* mutable_polygonvertices(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >*
+      mutable_polygonvertices();
+  private:
+  const ::proto::Point& _internal_polygonvertices(int index) const;
+  ::proto::Point* _internal_add_polygonvertices();
+  public:
+  const ::proto::Point& polygonvertices(int index) const;
+  ::proto::Point* add_polygonvertices();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >&
+      polygonvertices() const;
+
+  // .proto.Location location = 2;
+  bool has_location() const;
+  private:
+  bool _internal_has_location() const;
+  public:
+  void clear_location();
+  const ::proto::Location& location() const;
+  PROTOBUF_NODISCARD ::proto::Location* release_location();
+  ::proto::Location* mutable_location();
+  void set_allocated_location(::proto::Location* location);
+  private:
+  const ::proto::Location& _internal_location() const;
+  ::proto::Location* _internal_mutable_location();
+  public:
+  void unsafe_arena_set_allocated_location(
+      ::proto::Location* location);
+  ::proto::Location* unsafe_arena_release_location();
+
+  void clear_action();
+  ActionCase action_case() const;
+  // @@protoc_insertion_point(class_scope:proto.InteractiveAnnotation)
+ private:
+  class _Internal;
+  void set_has_location();
+
+  inline bool has_action() const;
+  inline void clear_has_action();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point > polygonvertices_;
+    union ActionUnion {
+      constexpr ActionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Location* location_;
+    } action_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeepInChat final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeepInChat) */ {
+ public:
+  inline KeepInChat() : KeepInChat(nullptr) {}
+  ~KeepInChat() override;
+  explicit PROTOBUF_CONSTEXPR KeepInChat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeepInChat(const KeepInChat& from);
+  KeepInChat(KeepInChat&& from) noexcept
+    : KeepInChat() {
+    *this = ::std::move(from);
+  }
+
+  inline KeepInChat& operator=(const KeepInChat& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeepInChat& operator=(KeepInChat&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeepInChat& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeepInChat* internal_default_instance() {
+    return reinterpret_cast<const KeepInChat*>(
+               &_KeepInChat_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    47;
+
+  friend void swap(KeepInChat& a, KeepInChat& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeepInChat* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeepInChat* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  KeepInChat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<KeepInChat>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeepInChat& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const KeepInChat& from) {
+    KeepInChat::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeepInChat* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.KeepInChat";
+  }
+  protected:
+  explicit KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceJidFieldNumber = 4,
+    kKeyFieldNumber = 3,
+    kServerTimestampFieldNumber = 2,
+    kKeepTypeFieldNumber = 1,
+  };
+  // optional string deviceJid = 4;
+  bool has_devicejid() const;
+  private:
+  bool _internal_has_devicejid() const;
+  public:
+  void clear_devicejid();
+  const std::string& devicejid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_devicejid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_devicejid();
+  PROTOBUF_NODISCARD std::string* release_devicejid();
+  void set_allocated_devicejid(std::string* devicejid);
+  private:
+  const std::string& _internal_devicejid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicejid(const std::string& value);
+  std::string* _internal_mutable_devicejid();
+  public:
+
+  // optional .proto.MessageKey key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional int64 serverTimestamp = 2;
+  bool has_servertimestamp() const;
+  private:
+  bool _internal_has_servertimestamp() const;
+  public:
+  void clear_servertimestamp();
+  int64_t servertimestamp() const;
+  void set_servertimestamp(int64_t value);
+  private:
+  int64_t _internal_servertimestamp() const;
+  void _internal_set_servertimestamp(int64_t value);
+  public:
+
+  // optional .proto.KeepType keepType = 1;
+  bool has_keeptype() const;
+  private:
+  bool _internal_has_keeptype() const;
+  public:
+  void clear_keeptype();
+  ::proto::KeepType keeptype() const;
+  void set_keeptype(::proto::KeepType value);
+  private:
+  ::proto::KeepType _internal_keeptype() const;
+  void _internal_set_keeptype(::proto::KeepType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.KeepInChat)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicejid_;
+    ::proto::MessageKey* key_;
+    int64_t servertimestamp_;
+    int keeptype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeyId) */ {
+ public:
+  inline KeyId() : KeyId(nullptr) {}
+  ~KeyId() override;
+  explicit PROTOBUF_CONSTEXPR KeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyId(const KeyId& from);
+  KeyId(KeyId&& from) noexcept
+    : KeyId() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyId& operator=(const KeyId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyId& operator=(KeyId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyId* internal_default_instance() {
+    return reinterpret_cast<const KeyId*>(
+               &_KeyId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    48;
+
+  friend void swap(KeyId& a, KeyId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyId* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  KeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<KeyId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const KeyId& from) {
+    KeyId::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyId* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.KeyId";
+  }
+  protected:
+  explicit KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+  };
+  // optional bytes id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.KeyId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LocalizedName final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.LocalizedName) */ {
+ public:
+  inline LocalizedName() : LocalizedName(nullptr) {}
+  ~LocalizedName() override;
+  explicit PROTOBUF_CONSTEXPR LocalizedName(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LocalizedName(const LocalizedName& from);
+  LocalizedName(LocalizedName&& from) noexcept
+    : LocalizedName() {
+    *this = ::std::move(from);
+  }
+
+  inline LocalizedName& operator=(const LocalizedName& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LocalizedName& operator=(LocalizedName&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LocalizedName& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LocalizedName* internal_default_instance() {
+    return reinterpret_cast<const LocalizedName*>(
+               &_LocalizedName_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    49;
+
+  friend void swap(LocalizedName& a, LocalizedName& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LocalizedName* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LocalizedName* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LocalizedName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LocalizedName>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LocalizedName& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const LocalizedName& from) {
+    LocalizedName::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LocalizedName* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.LocalizedName";
+  }
+  protected:
+  explicit LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLgFieldNumber = 1,
+    kLcFieldNumber = 2,
+    kVerifiedNameFieldNumber = 3,
+  };
+  // optional string lg = 1;
+  bool has_lg() const;
+  private:
+  bool _internal_has_lg() const;
+  public:
+  void clear_lg();
+  const std::string& lg() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_lg(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_lg();
+  PROTOBUF_NODISCARD std::string* release_lg();
+  void set_allocated_lg(std::string* lg);
+  private:
+  const std::string& _internal_lg() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lg(const std::string& value);
+  std::string* _internal_mutable_lg();
+  public:
+
+  // optional string lc = 2;
+  bool has_lc() const;
+  private:
+  bool _internal_has_lc() const;
+  public:
+  void clear_lc();
+  const std::string& lc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_lc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_lc();
+  PROTOBUF_NODISCARD std::string* release_lc();
+  void set_allocated_lc(std::string* lc);
+  private:
+  const std::string& _internal_lc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lc(const std::string& value);
+  std::string* _internal_mutable_lc();
+  public:
+
+  // optional string verifiedName = 3;
+  bool has_verifiedname() const;
+  private:
+  bool _internal_has_verifiedname() const;
+  public:
+  void clear_verifiedname();
+  const std::string& verifiedname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_verifiedname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_verifiedname();
+  PROTOBUF_NODISCARD std::string* release_verifiedname();
+  void set_allocated_verifiedname(std::string* verifiedname);
+  private:
+  const std::string& _internal_verifiedname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value);
+  std::string* _internal_mutable_verifiedname();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.LocalizedName)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lg_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lc_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Location final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Location) */ {
+ public:
+  inline Location() : Location(nullptr) {}
+  ~Location() override;
+  explicit PROTOBUF_CONSTEXPR Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Location(const Location& from);
+  Location(Location&& from) noexcept
+    : Location() {
+    *this = ::std::move(from);
+  }
+
+  inline Location& operator=(const Location& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Location& operator=(Location&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Location& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Location* internal_default_instance() {
+    return reinterpret_cast<const Location*>(
+               &_Location_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    50;
+
+  friend void swap(Location& a, Location& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Location* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Location* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Location>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Location& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Location& from) {
+    Location::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Location* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Location";
+  }
+  protected:
+  explicit Location(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 3,
+    kDegreesLatitudeFieldNumber = 1,
+    kDegreesLongitudeFieldNumber = 2,
+  };
+  // optional string name = 3;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional double degreesLatitude = 1;
+  bool has_degreeslatitude() const;
+  private:
+  bool _internal_has_degreeslatitude() const;
+  public:
+  void clear_degreeslatitude();
+  double degreeslatitude() const;
+  void set_degreeslatitude(double value);
+  private:
+  double _internal_degreeslatitude() const;
+  void _internal_set_degreeslatitude(double value);
+  public:
+
+  // optional double degreesLongitude = 2;
+  bool has_degreeslongitude() const;
+  private:
+  bool _internal_has_degreeslongitude() const;
+  public:
+  void clear_degreeslongitude();
+  double degreeslongitude() const;
+  void set_degreeslongitude(double value);
+  private:
+  double _internal_degreeslongitude() const;
+  void _internal_set_degreeslongitude(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Location)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    double degreeslatitude_;
+    double degreeslongitude_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MediaData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaData) */ {
+ public:
+  inline MediaData() : MediaData(nullptr) {}
+  ~MediaData() override;
+  explicit PROTOBUF_CONSTEXPR MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MediaData(const MediaData& from);
+  MediaData(MediaData&& from) noexcept
+    : MediaData() {
+    *this = ::std::move(from);
+  }
+
+  inline MediaData& operator=(const MediaData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MediaData& operator=(MediaData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MediaData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MediaData* internal_default_instance() {
+    return reinterpret_cast<const MediaData*>(
+               &_MediaData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    51;
+
+  friend void swap(MediaData& a, MediaData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MediaData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MediaData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MediaData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MediaData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MediaData& from) {
+    MediaData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MediaData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MediaData";
+  }
+  protected:
+  explicit MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLocalPathFieldNumber = 1,
+  };
+  // optional string localPath = 1;
+  bool has_localpath() const;
+  private:
+  bool _internal_has_localpath() const;
+  public:
+  void clear_localpath();
+  const std::string& localpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localpath();
+  PROTOBUF_NODISCARD std::string* release_localpath();
+  void set_allocated_localpath(std::string* localpath);
+  private:
+  const std::string& _internal_localpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localpath(const std::string& value);
+  std::string* _internal_mutable_localpath();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MediaData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localpath_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MediaRetryNotification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaRetryNotification) */ {
+ public:
+  inline MediaRetryNotification() : MediaRetryNotification(nullptr) {}
+  ~MediaRetryNotification() override;
+  explicit PROTOBUF_CONSTEXPR MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MediaRetryNotification(const MediaRetryNotification& from);
+  MediaRetryNotification(MediaRetryNotification&& from) noexcept
+    : MediaRetryNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline MediaRetryNotification& operator=(const MediaRetryNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MediaRetryNotification& operator=(MediaRetryNotification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MediaRetryNotification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MediaRetryNotification* internal_default_instance() {
+    return reinterpret_cast<const MediaRetryNotification*>(
+               &_MediaRetryNotification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    52;
+
+  friend void swap(MediaRetryNotification& a, MediaRetryNotification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MediaRetryNotification* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MediaRetryNotification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MediaRetryNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MediaRetryNotification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MediaRetryNotification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MediaRetryNotification& from) {
+    MediaRetryNotification::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MediaRetryNotification* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MediaRetryNotification";
+  }
+  protected:
+  explicit MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MediaRetryNotification_ResultType ResultType;
+  static constexpr ResultType GENERAL_ERROR =
+    MediaRetryNotification_ResultType_GENERAL_ERROR;
+  static constexpr ResultType SUCCESS =
+    MediaRetryNotification_ResultType_SUCCESS;
+  static constexpr ResultType NOT_FOUND =
+    MediaRetryNotification_ResultType_NOT_FOUND;
+  static constexpr ResultType DECRYPTION_ERROR =
+    MediaRetryNotification_ResultType_DECRYPTION_ERROR;
+  static inline bool ResultType_IsValid(int value) {
+    return MediaRetryNotification_ResultType_IsValid(value);
+  }
+  static constexpr ResultType ResultType_MIN =
+    MediaRetryNotification_ResultType_ResultType_MIN;
+  static constexpr ResultType ResultType_MAX =
+    MediaRetryNotification_ResultType_ResultType_MAX;
+  static constexpr int ResultType_ARRAYSIZE =
+    MediaRetryNotification_ResultType_ResultType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ResultType_descriptor() {
+    return MediaRetryNotification_ResultType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ResultType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ResultType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ResultType_Name.");
+    return MediaRetryNotification_ResultType_Name(enum_t_value);
+  }
+  static inline bool ResultType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ResultType* value) {
+    return MediaRetryNotification_ResultType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStanzaIdFieldNumber = 1,
+    kDirectPathFieldNumber = 2,
+    kResultFieldNumber = 3,
+  };
+  // optional string stanzaId = 1;
+  bool has_stanzaid() const;
+  private:
+  bool _internal_has_stanzaid() const;
+  public:
+  void clear_stanzaid();
+  const std::string& stanzaid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stanzaid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stanzaid();
+  PROTOBUF_NODISCARD std::string* release_stanzaid();
+  void set_allocated_stanzaid(std::string* stanzaid);
+  private:
+  const std::string& _internal_stanzaid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
+  std::string* _internal_mutable_stanzaid();
+  public:
+
+  // optional string directPath = 2;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional .proto.MediaRetryNotification.ResultType result = 3;
+  bool has_result() const;
+  private:
+  bool _internal_has_result() const;
+  public:
+  void clear_result();
+  ::proto::MediaRetryNotification_ResultType result() const;
+  void set_result(::proto::MediaRetryNotification_ResultType value);
+  private:
+  ::proto::MediaRetryNotification_ResultType _internal_result() const;
+  void _internal_set_result(::proto::MediaRetryNotification_ResultType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MediaRetryNotification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    int result_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateFatalExceptionNotification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateFatalExceptionNotification) */ {
+ public:
+  inline Message_AppStateFatalExceptionNotification() : Message_AppStateFatalExceptionNotification(nullptr) {}
+  ~Message_AppStateFatalExceptionNotification() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from);
+  Message_AppStateFatalExceptionNotification(Message_AppStateFatalExceptionNotification&& from) noexcept
+    : Message_AppStateFatalExceptionNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateFatalExceptionNotification& operator=(const Message_AppStateFatalExceptionNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateFatalExceptionNotification& operator=(Message_AppStateFatalExceptionNotification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateFatalExceptionNotification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateFatalExceptionNotification* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateFatalExceptionNotification*>(
+               &_Message_AppStateFatalExceptionNotification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    53;
+
+  friend void swap(Message_AppStateFatalExceptionNotification& a, Message_AppStateFatalExceptionNotification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateFatalExceptionNotification* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateFatalExceptionNotification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateFatalExceptionNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateFatalExceptionNotification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateFatalExceptionNotification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateFatalExceptionNotification& from) {
+    Message_AppStateFatalExceptionNotification::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateFatalExceptionNotification* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateFatalExceptionNotification";
+  }
+  protected:
+  explicit Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCollectionNamesFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+  };
+  // repeated string collectionNames = 1;
+  int collectionnames_size() const;
+  private:
+  int _internal_collectionnames_size() const;
+  public:
+  void clear_collectionnames();
+  const std::string& collectionnames(int index) const;
+  std::string* mutable_collectionnames(int index);
+  void set_collectionnames(int index, const std::string& value);
+  void set_collectionnames(int index, std::string&& value);
+  void set_collectionnames(int index, const char* value);
+  void set_collectionnames(int index, const char* value, size_t size);
+  std::string* add_collectionnames();
+  void add_collectionnames(const std::string& value);
+  void add_collectionnames(std::string&& value);
+  void add_collectionnames(const char* value);
+  void add_collectionnames(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collectionnames() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collectionnames();
+  private:
+  const std::string& _internal_collectionnames(int index) const;
+  std::string* _internal_add_collectionnames();
+  public:
+
+  // optional int64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateFatalExceptionNotification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> collectionnames_;
+    int64_t timestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKeyData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyData) */ {
+ public:
+  inline Message_AppStateSyncKeyData() : Message_AppStateSyncKeyData(nullptr) {}
+  ~Message_AppStateSyncKeyData() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from);
+  Message_AppStateSyncKeyData(Message_AppStateSyncKeyData&& from) noexcept
+    : Message_AppStateSyncKeyData() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKeyData& operator=(const Message_AppStateSyncKeyData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKeyData& operator=(Message_AppStateSyncKeyData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKeyData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKeyData* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKeyData*>(
+               &_Message_AppStateSyncKeyData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    54;
+
+  friend void swap(Message_AppStateSyncKeyData& a, Message_AppStateSyncKeyData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKeyData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKeyData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKeyData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKeyData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKeyData& from) {
+    Message_AppStateSyncKeyData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKeyData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKeyData";
+  }
+  protected:
+  explicit Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyDataFieldNumber = 1,
+    kFingerprintFieldNumber = 2,
+    kTimestampFieldNumber = 3,
+  };
+  // optional bytes keyData = 1;
+  bool has_keydata() const;
+  private:
+  bool _internal_has_keydata() const;
+  public:
+  void clear_keydata();
+  const std::string& keydata() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_keydata(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_keydata();
+  PROTOBUF_NODISCARD std::string* release_keydata();
+  void set_allocated_keydata(std::string* keydata);
+  private:
+  const std::string& _internal_keydata() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_keydata(const std::string& value);
+  std::string* _internal_mutable_keydata();
+  public:
+
+  // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
+  bool has_fingerprint() const;
+  private:
+  bool _internal_has_fingerprint() const;
+  public:
+  void clear_fingerprint();
+  const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyFingerprint* release_fingerprint();
+  ::proto::Message_AppStateSyncKeyFingerprint* mutable_fingerprint();
+  void set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint);
+  private:
+  const ::proto::Message_AppStateSyncKeyFingerprint& _internal_fingerprint() const;
+  ::proto::Message_AppStateSyncKeyFingerprint* _internal_mutable_fingerprint();
+  public:
+  void unsafe_arena_set_allocated_fingerprint(
+      ::proto::Message_AppStateSyncKeyFingerprint* fingerprint);
+  ::proto::Message_AppStateSyncKeyFingerprint* unsafe_arena_release_fingerprint();
+
+  // optional int64 timestamp = 3;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keydata_;
+    ::proto::Message_AppStateSyncKeyFingerprint* fingerprint_;
+    int64_t timestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKeyFingerprint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyFingerprint) */ {
+ public:
+  inline Message_AppStateSyncKeyFingerprint() : Message_AppStateSyncKeyFingerprint(nullptr) {}
+  ~Message_AppStateSyncKeyFingerprint() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from);
+  Message_AppStateSyncKeyFingerprint(Message_AppStateSyncKeyFingerprint&& from) noexcept
+    : Message_AppStateSyncKeyFingerprint() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKeyFingerprint& operator=(const Message_AppStateSyncKeyFingerprint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKeyFingerprint& operator=(Message_AppStateSyncKeyFingerprint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKeyFingerprint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKeyFingerprint* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKeyFingerprint*>(
+               &_Message_AppStateSyncKeyFingerprint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    55;
+
+  friend void swap(Message_AppStateSyncKeyFingerprint& a, Message_AppStateSyncKeyFingerprint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKeyFingerprint* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKeyFingerprint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKeyFingerprint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKeyFingerprint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKeyFingerprint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKeyFingerprint& from) {
+    Message_AppStateSyncKeyFingerprint::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKeyFingerprint* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKeyFingerprint";
+  }
+  protected:
+  explicit Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceIndexesFieldNumber = 3,
+    kRawIdFieldNumber = 1,
+    kCurrentIndexFieldNumber = 2,
+  };
+  // repeated uint32 deviceIndexes = 3 [packed = true];
+  int deviceindexes_size() const;
+  private:
+  int _internal_deviceindexes_size() const;
+  public:
+  void clear_deviceindexes();
+  private:
+  uint32_t _internal_deviceindexes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_deviceindexes() const;
+  void _internal_add_deviceindexes(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_deviceindexes();
+  public:
+  uint32_t deviceindexes(int index) const;
+  void set_deviceindexes(int index, uint32_t value);
+  void add_deviceindexes(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      deviceindexes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_deviceindexes();
+
+  // optional uint32 rawId = 1;
+  bool has_rawid() const;
+  private:
+  bool _internal_has_rawid() const;
+  public:
+  void clear_rawid();
+  uint32_t rawid() const;
+  void set_rawid(uint32_t value);
+  private:
+  uint32_t _internal_rawid() const;
+  void _internal_set_rawid(uint32_t value);
+  public:
+
+  // optional uint32 currentIndex = 2;
+  bool has_currentindex() const;
+  private:
+  bool _internal_has_currentindex() const;
+  public:
+  void clear_currentindex();
+  uint32_t currentindex() const;
+  void set_currentindex(uint32_t value);
+  private:
+  uint32_t _internal_currentindex() const;
+  void _internal_set_currentindex(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyFingerprint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > deviceindexes_;
+    mutable std::atomic<int> _deviceindexes_cached_byte_size_;
+    uint32_t rawid_;
+    uint32_t currentindex_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKeyId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyId) */ {
+ public:
+  inline Message_AppStateSyncKeyId() : Message_AppStateSyncKeyId(nullptr) {}
+  ~Message_AppStateSyncKeyId() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from);
+  Message_AppStateSyncKeyId(Message_AppStateSyncKeyId&& from) noexcept
+    : Message_AppStateSyncKeyId() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKeyId& operator=(const Message_AppStateSyncKeyId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKeyId& operator=(Message_AppStateSyncKeyId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKeyId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKeyId* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKeyId*>(
+               &_Message_AppStateSyncKeyId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    56;
+
+  friend void swap(Message_AppStateSyncKeyId& a, Message_AppStateSyncKeyId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKeyId* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKeyId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKeyId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKeyId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKeyId& from) {
+    Message_AppStateSyncKeyId::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKeyId* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKeyId";
+  }
+  protected:
+  explicit Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 1,
+  };
+  // optional bytes keyId = 1;
+  bool has_keyid() const;
+  private:
+  bool _internal_has_keyid() const;
+  public:
+  void clear_keyid();
+  const std::string& keyid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_keyid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_keyid();
+  PROTOBUF_NODISCARD std::string* release_keyid();
+  void set_allocated_keyid(std::string* keyid);
+  private:
+  const std::string& _internal_keyid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_keyid(const std::string& value);
+  std::string* _internal_mutable_keyid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keyid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKeyRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyRequest) */ {
+ public:
+  inline Message_AppStateSyncKeyRequest() : Message_AppStateSyncKeyRequest(nullptr) {}
+  ~Message_AppStateSyncKeyRequest() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from);
+  Message_AppStateSyncKeyRequest(Message_AppStateSyncKeyRequest&& from) noexcept
+    : Message_AppStateSyncKeyRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKeyRequest& operator=(const Message_AppStateSyncKeyRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKeyRequest& operator=(Message_AppStateSyncKeyRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKeyRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKeyRequest* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKeyRequest*>(
+               &_Message_AppStateSyncKeyRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    57;
+
+  friend void swap(Message_AppStateSyncKeyRequest& a, Message_AppStateSyncKeyRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKeyRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKeyRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKeyRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKeyRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKeyRequest& from) {
+    Message_AppStateSyncKeyRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKeyRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKeyRequest";
+  }
+  protected:
+  explicit Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdsFieldNumber = 1,
+  };
+  // repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
+  int keyids_size() const;
+  private:
+  int _internal_keyids_size() const;
+  public:
+  void clear_keyids();
+  ::proto::Message_AppStateSyncKeyId* mutable_keyids(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >*
+      mutable_keyids();
+  private:
+  const ::proto::Message_AppStateSyncKeyId& _internal_keyids(int index) const;
+  ::proto::Message_AppStateSyncKeyId* _internal_add_keyids();
+  public:
+  const ::proto::Message_AppStateSyncKeyId& keyids(int index) const;
+  ::proto::Message_AppStateSyncKeyId* add_keyids();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >&
+      keyids() const;
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId > keyids_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKeyShare final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyShare) */ {
+ public:
+  inline Message_AppStateSyncKeyShare() : Message_AppStateSyncKeyShare(nullptr) {}
+  ~Message_AppStateSyncKeyShare() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from);
+  Message_AppStateSyncKeyShare(Message_AppStateSyncKeyShare&& from) noexcept
+    : Message_AppStateSyncKeyShare() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKeyShare& operator=(const Message_AppStateSyncKeyShare& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKeyShare& operator=(Message_AppStateSyncKeyShare&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKeyShare& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKeyShare* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKeyShare*>(
+               &_Message_AppStateSyncKeyShare_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    58;
+
+  friend void swap(Message_AppStateSyncKeyShare& a, Message_AppStateSyncKeyShare& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKeyShare* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKeyShare* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKeyShare* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKeyShare>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKeyShare& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKeyShare& from) {
+    Message_AppStateSyncKeyShare::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKeyShare* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKeyShare";
+  }
+  protected:
+  explicit Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeysFieldNumber = 1,
+  };
+  // repeated .proto.Message.AppStateSyncKey keys = 1;
+  int keys_size() const;
+  private:
+  int _internal_keys_size() const;
+  public:
+  void clear_keys();
+  ::proto::Message_AppStateSyncKey* mutable_keys(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >*
+      mutable_keys();
+  private:
+  const ::proto::Message_AppStateSyncKey& _internal_keys(int index) const;
+  ::proto::Message_AppStateSyncKey* _internal_add_keys();
+  public:
+  const ::proto::Message_AppStateSyncKey& keys(int index) const;
+  ::proto::Message_AppStateSyncKey* add_keys();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >&
+      keys() const;
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyShare)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey > keys_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AppStateSyncKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKey) */ {
+ public:
+  inline Message_AppStateSyncKey() : Message_AppStateSyncKey(nullptr) {}
+  ~Message_AppStateSyncKey() override;
+  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AppStateSyncKey(const Message_AppStateSyncKey& from);
+  Message_AppStateSyncKey(Message_AppStateSyncKey&& from) noexcept
+    : Message_AppStateSyncKey() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AppStateSyncKey& operator=(const Message_AppStateSyncKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AppStateSyncKey& operator=(Message_AppStateSyncKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AppStateSyncKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AppStateSyncKey* internal_default_instance() {
+    return reinterpret_cast<const Message_AppStateSyncKey*>(
+               &_Message_AppStateSyncKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    59;
+
+  friend void swap(Message_AppStateSyncKey& a, Message_AppStateSyncKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AppStateSyncKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AppStateSyncKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AppStateSyncKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AppStateSyncKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AppStateSyncKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AppStateSyncKey& from) {
+    Message_AppStateSyncKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AppStateSyncKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AppStateSyncKey";
+  }
+  protected:
+  explicit Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 1,
+    kKeyDataFieldNumber = 2,
+  };
+  // optional .proto.Message.AppStateSyncKeyId keyId = 1;
+  bool has_keyid() const;
+  private:
+  bool _internal_has_keyid() const;
+  public:
+  void clear_keyid();
+  const ::proto::Message_AppStateSyncKeyId& keyid() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyId* release_keyid();
+  ::proto::Message_AppStateSyncKeyId* mutable_keyid();
+  void set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid);
+  private:
+  const ::proto::Message_AppStateSyncKeyId& _internal_keyid() const;
+  ::proto::Message_AppStateSyncKeyId* _internal_mutable_keyid();
+  public:
+  void unsafe_arena_set_allocated_keyid(
+      ::proto::Message_AppStateSyncKeyId* keyid);
+  ::proto::Message_AppStateSyncKeyId* unsafe_arena_release_keyid();
+
+  // optional .proto.Message.AppStateSyncKeyData keyData = 2;
+  bool has_keydata() const;
+  private:
+  bool _internal_has_keydata() const;
+  public:
+  void clear_keydata();
+  const ::proto::Message_AppStateSyncKeyData& keydata() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyData* release_keydata();
+  ::proto::Message_AppStateSyncKeyData* mutable_keydata();
+  void set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata);
+  private:
+  const ::proto::Message_AppStateSyncKeyData& _internal_keydata() const;
+  ::proto::Message_AppStateSyncKeyData* _internal_mutable_keydata();
+  public:
+  void unsafe_arena_set_allocated_keydata(
+      ::proto::Message_AppStateSyncKeyData* keydata);
+  ::proto::Message_AppStateSyncKeyData* unsafe_arena_release_keydata();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message_AppStateSyncKeyId* keyid_;
+    ::proto::Message_AppStateSyncKeyData* keydata_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_AudioMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AudioMessage) */ {
+ public:
+  inline Message_AudioMessage() : Message_AudioMessage(nullptr) {}
+  ~Message_AudioMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_AudioMessage(const Message_AudioMessage& from);
+  Message_AudioMessage(Message_AudioMessage&& from) noexcept
+    : Message_AudioMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_AudioMessage& operator=(const Message_AudioMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_AudioMessage& operator=(Message_AudioMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_AudioMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_AudioMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_AudioMessage*>(
+               &_Message_AudioMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    60;
+
+  friend void swap(Message_AudioMessage& a, Message_AudioMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_AudioMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_AudioMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_AudioMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_AudioMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_AudioMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_AudioMessage& from) {
+    Message_AudioMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_AudioMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.AudioMessage";
+  }
+  protected:
+  explicit Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kMimetypeFieldNumber = 2,
+    kFileSha256FieldNumber = 3,
+    kMediaKeyFieldNumber = 7,
+    kFileEncSha256FieldNumber = 8,
+    kDirectPathFieldNumber = 9,
+    kStreamingSidecarFieldNumber = 18,
+    kWaveformFieldNumber = 19,
+    kContextInfoFieldNumber = 17,
+    kFileLengthFieldNumber = 4,
+    kSecondsFieldNumber = 5,
+    kPttFieldNumber = 6,
+    kMediaKeyTimestampFieldNumber = 10,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string mimetype = 2;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional bytes fileSha256 = 3;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes mediaKey = 7;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional bytes fileEncSha256 = 8;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 9;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional bytes streamingSidecar = 18;
+  bool has_streamingsidecar() const;
+  private:
+  bool _internal_has_streamingsidecar() const;
+  public:
+  void clear_streamingsidecar();
+  const std::string& streamingsidecar() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_streamingsidecar(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_streamingsidecar();
+  PROTOBUF_NODISCARD std::string* release_streamingsidecar();
+  void set_allocated_streamingsidecar(std::string* streamingsidecar);
+  private:
+  const std::string& _internal_streamingsidecar() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value);
+  std::string* _internal_mutable_streamingsidecar();
+  public:
+
+  // optional bytes waveform = 19;
+  bool has_waveform() const;
+  private:
+  bool _internal_has_waveform() const;
+  public:
+  void clear_waveform();
+  const std::string& waveform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_waveform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_waveform();
+  PROTOBUF_NODISCARD std::string* release_waveform();
+  void set_allocated_waveform(std::string* waveform);
+  private:
+  const std::string& _internal_waveform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_waveform(const std::string& value);
+  std::string* _internal_mutable_waveform();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint64 fileLength = 4;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional uint32 seconds = 5;
+  bool has_seconds() const;
+  private:
+  bool _internal_has_seconds() const;
+  public:
+  void clear_seconds();
+  uint32_t seconds() const;
+  void set_seconds(uint32_t value);
+  private:
+  uint32_t _internal_seconds() const;
+  void _internal_set_seconds(uint32_t value);
+  public:
+
+  // optional bool ptt = 6;
+  bool has_ptt() const;
+  private:
+  bool _internal_has_ptt() const;
+  public:
+  void clear_ptt();
+  bool ptt() const;
+  void set_ptt(bool value);
+  private:
+  bool _internal_ptt() const;
+  void _internal_set_ptt(bool value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 10;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.AudioMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr waveform_;
+    ::proto::ContextInfo* contextinfo_;
+    uint64_t filelength_;
+    uint32_t seconds_;
+    bool ptt_;
+    int64_t mediakeytimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ButtonsMessage_Button_ButtonText final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.ButtonText) */ {
+ public:
+  inline Message_ButtonsMessage_Button_ButtonText() : Message_ButtonsMessage_Button_ButtonText(nullptr) {}
+  ~Message_ButtonsMessage_Button_ButtonText() override;
+  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from);
+  Message_ButtonsMessage_Button_ButtonText(Message_ButtonsMessage_Button_ButtonText&& from) noexcept
+    : Message_ButtonsMessage_Button_ButtonText() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ButtonsMessage_Button_ButtonText& operator=(const Message_ButtonsMessage_Button_ButtonText& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ButtonsMessage_Button_ButtonText& operator=(Message_ButtonsMessage_Button_ButtonText&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ButtonsMessage_Button_ButtonText& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ButtonsMessage_Button_ButtonText* internal_default_instance() {
+    return reinterpret_cast<const Message_ButtonsMessage_Button_ButtonText*>(
+               &_Message_ButtonsMessage_Button_ButtonText_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    61;
+
+  friend void swap(Message_ButtonsMessage_Button_ButtonText& a, Message_ButtonsMessage_Button_ButtonText& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ButtonsMessage_Button_ButtonText* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ButtonsMessage_Button_ButtonText* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ButtonsMessage_Button_ButtonText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ButtonsMessage_Button_ButtonText>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ButtonsMessage_Button_ButtonText& from) {
+    Message_ButtonsMessage_Button_ButtonText::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ButtonsMessage_Button_ButtonText* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ButtonsMessage.Button.ButtonText";
+  }
+  protected:
+  explicit Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+  };
+  // optional string displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const std::string& displaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displaytext();
+  PROTOBUF_NODISCARD std::string* release_displaytext();
+  void set_allocated_displaytext(std::string* displaytext);
+  private:
+  const std::string& _internal_displaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
+  std::string* _internal_mutable_displaytext();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.ButtonText)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ButtonsMessage_Button_NativeFlowInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.NativeFlowInfo) */ {
+ public:
+  inline Message_ButtonsMessage_Button_NativeFlowInfo() : Message_ButtonsMessage_Button_NativeFlowInfo(nullptr) {}
+  ~Message_ButtonsMessage_Button_NativeFlowInfo() override;
+  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from);
+  Message_ButtonsMessage_Button_NativeFlowInfo(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept
+    : Message_ButtonsMessage_Button_NativeFlowInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(const Message_ButtonsMessage_Button_NativeFlowInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ButtonsMessage_Button_NativeFlowInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ButtonsMessage_Button_NativeFlowInfo* internal_default_instance() {
+    return reinterpret_cast<const Message_ButtonsMessage_Button_NativeFlowInfo*>(
+               &_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    62;
+
+  friend void swap(Message_ButtonsMessage_Button_NativeFlowInfo& a, Message_ButtonsMessage_Button_NativeFlowInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ButtonsMessage_Button_NativeFlowInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ButtonsMessage_Button_NativeFlowInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ButtonsMessage_Button_NativeFlowInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ButtonsMessage_Button_NativeFlowInfo& from) {
+    Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ButtonsMessage.Button.NativeFlowInfo";
+  }
+  protected:
+  explicit Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kParamsJsonFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string paramsJson = 2;
+  bool has_paramsjson() const;
+  private:
+  bool _internal_has_paramsjson() const;
+  public:
+  void clear_paramsjson();
+  const std::string& paramsjson() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_paramsjson(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_paramsjson();
+  PROTOBUF_NODISCARD std::string* release_paramsjson();
+  void set_allocated_paramsjson(std::string* paramsjson);
+  private:
+  const std::string& _internal_paramsjson() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value);
+  std::string* _internal_mutable_paramsjson();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ButtonsMessage_Button final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button) */ {
+ public:
+  inline Message_ButtonsMessage_Button() : Message_ButtonsMessage_Button(nullptr) {}
+  ~Message_ButtonsMessage_Button() override;
+  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from);
+  Message_ButtonsMessage_Button(Message_ButtonsMessage_Button&& from) noexcept
+    : Message_ButtonsMessage_Button() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ButtonsMessage_Button& operator=(const Message_ButtonsMessage_Button& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ButtonsMessage_Button& operator=(Message_ButtonsMessage_Button&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ButtonsMessage_Button& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ButtonsMessage_Button* internal_default_instance() {
+    return reinterpret_cast<const Message_ButtonsMessage_Button*>(
+               &_Message_ButtonsMessage_Button_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    63;
+
+  friend void swap(Message_ButtonsMessage_Button& a, Message_ButtonsMessage_Button& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ButtonsMessage_Button* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ButtonsMessage_Button* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ButtonsMessage_Button* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ButtonsMessage_Button>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ButtonsMessage_Button& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ButtonsMessage_Button& from) {
+    Message_ButtonsMessage_Button::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ButtonsMessage_Button* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ButtonsMessage.Button";
+  }
+  protected:
+  explicit Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ButtonsMessage_Button_ButtonText ButtonText;
+  typedef Message_ButtonsMessage_Button_NativeFlowInfo NativeFlowInfo;
+
+  typedef Message_ButtonsMessage_Button_Type Type;
+  static constexpr Type UNKNOWN =
+    Message_ButtonsMessage_Button_Type_UNKNOWN;
+  static constexpr Type RESPONSE =
+    Message_ButtonsMessage_Button_Type_RESPONSE;
+  static constexpr Type NATIVE_FLOW =
+    Message_ButtonsMessage_Button_Type_NATIVE_FLOW;
+  static inline bool Type_IsValid(int value) {
+    return Message_ButtonsMessage_Button_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    Message_ButtonsMessage_Button_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    Message_ButtonsMessage_Button_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return Message_ButtonsMessage_Button_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return Message_ButtonsMessage_Button_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return Message_ButtonsMessage_Button_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kButtonIdFieldNumber = 1,
+    kButtonTextFieldNumber = 2,
+    kNativeFlowInfoFieldNumber = 4,
+    kTypeFieldNumber = 3,
+  };
+  // optional string buttonId = 1;
+  bool has_buttonid() const;
+  private:
+  bool _internal_has_buttonid() const;
+  public:
+  void clear_buttonid();
+  const std::string& buttonid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_buttonid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_buttonid();
+  PROTOBUF_NODISCARD std::string* release_buttonid();
+  void set_allocated_buttonid(std::string* buttonid);
+  private:
+  const std::string& _internal_buttonid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonid(const std::string& value);
+  std::string* _internal_mutable_buttonid();
+  public:
+
+  // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
+  bool has_buttontext() const;
+  private:
+  bool _internal_has_buttontext() const;
+  public:
+  void clear_buttontext();
+  const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext() const;
+  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_ButtonText* release_buttontext();
+  ::proto::Message_ButtonsMessage_Button_ButtonText* mutable_buttontext();
+  void set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext);
+  private:
+  const ::proto::Message_ButtonsMessage_Button_ButtonText& _internal_buttontext() const;
+  ::proto::Message_ButtonsMessage_Button_ButtonText* _internal_mutable_buttontext();
+  public:
+  void unsafe_arena_set_allocated_buttontext(
+      ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext);
+  ::proto::Message_ButtonsMessage_Button_ButtonText* unsafe_arena_release_buttontext();
+
+  // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
+  bool has_nativeflowinfo() const;
+  private:
+  bool _internal_has_nativeflowinfo() const;
+  public:
+  void clear_nativeflowinfo();
+  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo() const;
+  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* release_nativeflowinfo();
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* mutable_nativeflowinfo();
+  void set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo);
+  private:
+  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& _internal_nativeflowinfo() const;
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _internal_mutable_nativeflowinfo();
+  public:
+  void unsafe_arena_set_allocated_nativeflowinfo(
+      ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo);
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* unsafe_arena_release_nativeflowinfo();
+
+  // optional .proto.Message.ButtonsMessage.Button.Type type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::proto::Message_ButtonsMessage_Button_Type type() const;
+  void set_type(::proto::Message_ButtonsMessage_Button_Type value);
+  private:
+  ::proto::Message_ButtonsMessage_Button_Type _internal_type() const;
+  void _internal_set_type(::proto::Message_ButtonsMessage_Button_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonid_;
+    ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext_;
+    ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ButtonsMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage) */ {
+ public:
+  inline Message_ButtonsMessage() : Message_ButtonsMessage(nullptr) {}
+  ~Message_ButtonsMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ButtonsMessage(const Message_ButtonsMessage& from);
+  Message_ButtonsMessage(Message_ButtonsMessage&& from) noexcept
+    : Message_ButtonsMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ButtonsMessage& operator=(const Message_ButtonsMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ButtonsMessage& operator=(Message_ButtonsMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ButtonsMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  enum HeaderCase {
+    kText = 1,
+    kDocumentMessage = 2,
+    kImageMessage = 3,
+    kVideoMessage = 4,
+    kLocationMessage = 5,
+    HEADER_NOT_SET = 0,
+  };
+
+  static inline const Message_ButtonsMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ButtonsMessage*>(
+               &_Message_ButtonsMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    64;
+
+  friend void swap(Message_ButtonsMessage& a, Message_ButtonsMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ButtonsMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ButtonsMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ButtonsMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ButtonsMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ButtonsMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ButtonsMessage& from) {
+    Message_ButtonsMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ButtonsMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ButtonsMessage";
+  }
+  protected:
+  explicit Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ButtonsMessage_Button Button;
+
+  typedef Message_ButtonsMessage_HeaderType HeaderType;
+  static constexpr HeaderType UNKNOWN =
+    Message_ButtonsMessage_HeaderType_UNKNOWN;
+  static constexpr HeaderType EMPTY =
+    Message_ButtonsMessage_HeaderType_EMPTY;
+  static constexpr HeaderType TEXT =
+    Message_ButtonsMessage_HeaderType_TEXT;
+  static constexpr HeaderType DOCUMENT =
+    Message_ButtonsMessage_HeaderType_DOCUMENT;
+  static constexpr HeaderType IMAGE =
+    Message_ButtonsMessage_HeaderType_IMAGE;
+  static constexpr HeaderType VIDEO =
+    Message_ButtonsMessage_HeaderType_VIDEO;
+  static constexpr HeaderType LOCATION =
+    Message_ButtonsMessage_HeaderType_LOCATION;
+  static inline bool HeaderType_IsValid(int value) {
+    return Message_ButtonsMessage_HeaderType_IsValid(value);
+  }
+  static constexpr HeaderType HeaderType_MIN =
+    Message_ButtonsMessage_HeaderType_HeaderType_MIN;
+  static constexpr HeaderType HeaderType_MAX =
+    Message_ButtonsMessage_HeaderType_HeaderType_MAX;
+  static constexpr int HeaderType_ARRAYSIZE =
+    Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HeaderType_descriptor() {
+    return Message_ButtonsMessage_HeaderType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HeaderType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HeaderType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HeaderType_Name.");
+    return Message_ButtonsMessage_HeaderType_Name(enum_t_value);
+  }
+  static inline bool HeaderType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HeaderType* value) {
+    return Message_ButtonsMessage_HeaderType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kButtonsFieldNumber = 9,
+    kContentTextFieldNumber = 6,
+    kFooterTextFieldNumber = 7,
+    kContextInfoFieldNumber = 8,
+    kHeaderTypeFieldNumber = 10,
+    kTextFieldNumber = 1,
+    kDocumentMessageFieldNumber = 2,
+    kImageMessageFieldNumber = 3,
+    kVideoMessageFieldNumber = 4,
+    kLocationMessageFieldNumber = 5,
+  };
+  // repeated .proto.Message.ButtonsMessage.Button buttons = 9;
+  int buttons_size() const;
+  private:
+  int _internal_buttons_size() const;
+  public:
+  void clear_buttons();
+  ::proto::Message_ButtonsMessage_Button* mutable_buttons(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >*
+      mutable_buttons();
+  private:
+  const ::proto::Message_ButtonsMessage_Button& _internal_buttons(int index) const;
+  ::proto::Message_ButtonsMessage_Button* _internal_add_buttons();
+  public:
+  const ::proto::Message_ButtonsMessage_Button& buttons(int index) const;
+  ::proto::Message_ButtonsMessage_Button* add_buttons();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >&
+      buttons() const;
+
+  // optional string contentText = 6;
+  bool has_contenttext() const;
+  private:
+  bool _internal_has_contenttext() const;
+  public:
+  void clear_contenttext();
+  const std::string& contenttext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_contenttext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_contenttext();
+  PROTOBUF_NODISCARD std::string* release_contenttext();
+  void set_allocated_contenttext(std::string* contenttext);
+  private:
+  const std::string& _internal_contenttext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttext(const std::string& value);
+  std::string* _internal_mutable_contenttext();
+  public:
+
+  // optional string footerText = 7;
+  bool has_footertext() const;
+  private:
+  bool _internal_has_footertext() const;
+  public:
+  void clear_footertext();
+  const std::string& footertext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_footertext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_footertext();
+  PROTOBUF_NODISCARD std::string* release_footertext();
+  void set_allocated_footertext(std::string* footertext);
+  private:
+  const std::string& _internal_footertext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value);
+  std::string* _internal_mutable_footertext();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 8;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
+  bool has_headertype() const;
+  private:
+  bool _internal_has_headertype() const;
+  public:
+  void clear_headertype();
+  ::proto::Message_ButtonsMessage_HeaderType headertype() const;
+  void set_headertype(::proto::Message_ButtonsMessage_HeaderType value);
+  private:
+  ::proto::Message_ButtonsMessage_HeaderType _internal_headertype() const;
+  void _internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value);
+  public:
+
+  // string text = 1;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // .proto.Message.DocumentMessage documentMessage = 2;
+  bool has_documentmessage() const;
+  private:
+  bool _internal_has_documentmessage() const;
+  public:
+  void clear_documentmessage();
+  const ::proto::Message_DocumentMessage& documentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
+  ::proto::Message_DocumentMessage* mutable_documentmessage();
+  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
+  private:
+  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
+  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
+  public:
+  void unsafe_arena_set_allocated_documentmessage(
+      ::proto::Message_DocumentMessage* documentmessage);
+  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();
+
+  // .proto.Message.ImageMessage imageMessage = 3;
+  bool has_imagemessage() const;
+  private:
+  bool _internal_has_imagemessage() const;
+  public:
+  void clear_imagemessage();
+  const ::proto::Message_ImageMessage& imagemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
+  ::proto::Message_ImageMessage* mutable_imagemessage();
+  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
+  public:
+  void unsafe_arena_set_allocated_imagemessage(
+      ::proto::Message_ImageMessage* imagemessage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();
+
+  // .proto.Message.VideoMessage videoMessage = 4;
+  bool has_videomessage() const;
+  private:
+  bool _internal_has_videomessage() const;
+  public:
+  void clear_videomessage();
+  const ::proto::Message_VideoMessage& videomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
+  ::proto::Message_VideoMessage* mutable_videomessage();
+  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
+  private:
+  const ::proto::Message_VideoMessage& _internal_videomessage() const;
+  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
+  public:
+  void unsafe_arena_set_allocated_videomessage(
+      ::proto::Message_VideoMessage* videomessage);
+  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();
+
+  // .proto.Message.LocationMessage locationMessage = 5;
+  bool has_locationmessage() const;
+  private:
+  bool _internal_has_locationmessage() const;
+  public:
+  void clear_locationmessage();
+  const ::proto::Message_LocationMessage& locationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
+  ::proto::Message_LocationMessage* mutable_locationmessage();
+  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
+  private:
+  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
+  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
+  public:
+  void unsafe_arena_set_allocated_locationmessage(
+      ::proto::Message_LocationMessage* locationmessage);
+  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();
+
+  void clear_header();
+  HeaderCase header_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage)
+ private:
+  class _Internal;
+  void set_has_text();
+  void set_has_documentmessage();
+  void set_has_imagemessage();
+  void set_has_videomessage();
+  void set_has_locationmessage();
+
+  inline bool has_header() const;
+  inline void clear_has_header();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button > buttons_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_;
+    ::proto::ContextInfo* contextinfo_;
+    int headertype_;
+    union HeaderUnion {
+      constexpr HeaderUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+      ::proto::Message_DocumentMessage* documentmessage_;
+      ::proto::Message_ImageMessage* imagemessage_;
+      ::proto::Message_VideoMessage* videomessage_;
+      ::proto::Message_LocationMessage* locationmessage_;
+    } header_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ButtonsResponseMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsResponseMessage) */ {
+ public:
+  inline Message_ButtonsResponseMessage() : Message_ButtonsResponseMessage(nullptr) {}
+  ~Message_ButtonsResponseMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from);
+  Message_ButtonsResponseMessage(Message_ButtonsResponseMessage&& from) noexcept
+    : Message_ButtonsResponseMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ButtonsResponseMessage& operator=(const Message_ButtonsResponseMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ButtonsResponseMessage& operator=(Message_ButtonsResponseMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ButtonsResponseMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ResponseCase {
+    kSelectedDisplayText = 2,
+    RESPONSE_NOT_SET = 0,
+  };
+
+  static inline const Message_ButtonsResponseMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ButtonsResponseMessage*>(
+               &_Message_ButtonsResponseMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    65;
+
+  friend void swap(Message_ButtonsResponseMessage& a, Message_ButtonsResponseMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ButtonsResponseMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ButtonsResponseMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ButtonsResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ButtonsResponseMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ButtonsResponseMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ButtonsResponseMessage& from) {
+    Message_ButtonsResponseMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ButtonsResponseMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ButtonsResponseMessage";
+  }
+  protected:
+  explicit Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ButtonsResponseMessage_Type Type;
+  static constexpr Type UNKNOWN =
+    Message_ButtonsResponseMessage_Type_UNKNOWN;
+  static constexpr Type DISPLAY_TEXT =
+    Message_ButtonsResponseMessage_Type_DISPLAY_TEXT;
+  static inline bool Type_IsValid(int value) {
+    return Message_ButtonsResponseMessage_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    Message_ButtonsResponseMessage_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    Message_ButtonsResponseMessage_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return Message_ButtonsResponseMessage_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return Message_ButtonsResponseMessage_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return Message_ButtonsResponseMessage_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectedButtonIdFieldNumber = 1,
+    kContextInfoFieldNumber = 3,
+    kTypeFieldNumber = 4,
+    kSelectedDisplayTextFieldNumber = 2,
+  };
+  // optional string selectedButtonId = 1;
+  bool has_selectedbuttonid() const;
+  private:
+  bool _internal_has_selectedbuttonid() const;
+  public:
+  void clear_selectedbuttonid();
+  const std::string& selectedbuttonid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_selectedbuttonid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_selectedbuttonid();
+  PROTOBUF_NODISCARD std::string* release_selectedbuttonid();
+  void set_allocated_selectedbuttonid(std::string* selectedbuttonid);
+  private:
+  const std::string& _internal_selectedbuttonid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedbuttonid(const std::string& value);
+  std::string* _internal_mutable_selectedbuttonid();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 3;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional .proto.Message.ButtonsResponseMessage.Type type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::proto::Message_ButtonsResponseMessage_Type type() const;
+  void set_type(::proto::Message_ButtonsResponseMessage_Type value);
+  private:
+  ::proto::Message_ButtonsResponseMessage_Type _internal_type() const;
+  void _internal_set_type(::proto::Message_ButtonsResponseMessage_Type value);
+  public:
+
+  // string selectedDisplayText = 2;
+  bool has_selecteddisplaytext() const;
+  private:
+  bool _internal_has_selecteddisplaytext() const;
+  public:
+  void clear_selecteddisplaytext();
+  const std::string& selecteddisplaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_selecteddisplaytext();
+  PROTOBUF_NODISCARD std::string* release_selecteddisplaytext();
+  void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext);
+  private:
+  const std::string& _internal_selecteddisplaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value);
+  std::string* _internal_mutable_selecteddisplaytext();
+  public:
+
+  void clear_response();
+  ResponseCase response_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsResponseMessage)
+ private:
+  class _Internal;
+  void set_has_selecteddisplaytext();
+
+  inline bool has_response() const;
+  inline void clear_has_response();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedbuttonid_;
+    ::proto::ContextInfo* contextinfo_;
+    int type_;
+    union ResponseUnion {
+      constexpr ResponseUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_;
+    } response_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_Call final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Call) */ {
+ public:
+  inline Message_Call() : Message_Call(nullptr) {}
+  ~Message_Call() override;
+  explicit PROTOBUF_CONSTEXPR Message_Call(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_Call(const Message_Call& from);
+  Message_Call(Message_Call&& from) noexcept
+    : Message_Call() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_Call& operator=(const Message_Call& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_Call& operator=(Message_Call&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_Call& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_Call* internal_default_instance() {
+    return reinterpret_cast<const Message_Call*>(
+               &_Message_Call_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    66;
+
+  friend void swap(Message_Call& a, Message_Call& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_Call* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_Call* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_Call* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_Call>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_Call& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_Call& from) {
+    Message_Call::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_Call* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.Call";
+  }
+  protected:
+  explicit Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCallKeyFieldNumber = 1,
+    kConversionSourceFieldNumber = 2,
+    kConversionDataFieldNumber = 3,
+    kConversionDelaySecondsFieldNumber = 4,
+  };
+  // optional bytes callKey = 1;
+  bool has_callkey() const;
+  private:
+  bool _internal_has_callkey() const;
+  public:
+  void clear_callkey();
+  const std::string& callkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_callkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_callkey();
+  PROTOBUF_NODISCARD std::string* release_callkey();
+  void set_allocated_callkey(std::string* callkey);
+  private:
+  const std::string& _internal_callkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callkey(const std::string& value);
+  std::string* _internal_mutable_callkey();
+  public:
+
+  // optional string conversionSource = 2;
+  bool has_conversionsource() const;
+  private:
+  bool _internal_has_conversionsource() const;
+  public:
+  void clear_conversionsource();
+  const std::string& conversionsource() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_conversionsource(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_conversionsource();
+  PROTOBUF_NODISCARD std::string* release_conversionsource();
+  void set_allocated_conversionsource(std::string* conversionsource);
+  private:
+  const std::string& _internal_conversionsource() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value);
+  std::string* _internal_mutable_conversionsource();
+  public:
+
+  // optional bytes conversionData = 3;
+  bool has_conversiondata() const;
+  private:
+  bool _internal_has_conversiondata() const;
+  public:
+  void clear_conversiondata();
+  const std::string& conversiondata() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_conversiondata(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_conversiondata();
+  PROTOBUF_NODISCARD std::string* release_conversiondata();
+  void set_allocated_conversiondata(std::string* conversiondata);
+  private:
+  const std::string& _internal_conversiondata() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value);
+  std::string* _internal_mutable_conversiondata();
+  public:
+
+  // optional uint32 conversionDelaySeconds = 4;
+  bool has_conversiondelayseconds() const;
+  private:
+  bool _internal_has_conversiondelayseconds() const;
+  public:
+  void clear_conversiondelayseconds();
+  uint32_t conversiondelayseconds() const;
+  void set_conversiondelayseconds(uint32_t value);
+  private:
+  uint32_t _internal_conversiondelayseconds() const;
+  void _internal_set_conversiondelayseconds(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.Call)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callkey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_;
+    uint32_t conversiondelayseconds_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_CancelPaymentRequestMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.CancelPaymentRequestMessage) */ {
+ public:
+  inline Message_CancelPaymentRequestMessage() : Message_CancelPaymentRequestMessage(nullptr) {}
+  ~Message_CancelPaymentRequestMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from);
+  Message_CancelPaymentRequestMessage(Message_CancelPaymentRequestMessage&& from) noexcept
+    : Message_CancelPaymentRequestMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_CancelPaymentRequestMessage& operator=(const Message_CancelPaymentRequestMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_CancelPaymentRequestMessage& operator=(Message_CancelPaymentRequestMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_CancelPaymentRequestMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_CancelPaymentRequestMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_CancelPaymentRequestMessage*>(
+               &_Message_CancelPaymentRequestMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    67;
+
+  friend void swap(Message_CancelPaymentRequestMessage& a, Message_CancelPaymentRequestMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_CancelPaymentRequestMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_CancelPaymentRequestMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_CancelPaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_CancelPaymentRequestMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_CancelPaymentRequestMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_CancelPaymentRequestMessage& from) {
+    Message_CancelPaymentRequestMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_CancelPaymentRequestMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.CancelPaymentRequestMessage";
+  }
+  protected:
+  explicit Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+  };
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.CancelPaymentRequestMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* key_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_Chat final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Chat) */ {
+ public:
+  inline Message_Chat() : Message_Chat(nullptr) {}
+  ~Message_Chat() override;
+  explicit PROTOBUF_CONSTEXPR Message_Chat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_Chat(const Message_Chat& from);
+  Message_Chat(Message_Chat&& from) noexcept
+    : Message_Chat() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_Chat& operator=(const Message_Chat& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_Chat& operator=(Message_Chat&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_Chat& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_Chat* internal_default_instance() {
+    return reinterpret_cast<const Message_Chat*>(
+               &_Message_Chat_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    68;
+
+  friend void swap(Message_Chat& a, Message_Chat& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_Chat* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_Chat* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_Chat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_Chat>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_Chat& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_Chat& from) {
+    Message_Chat::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_Chat* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.Chat";
+  }
+  protected:
+  explicit Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayNameFieldNumber = 1,
+    kIdFieldNumber = 2,
+  };
+  // optional string displayName = 1;
+  bool has_displayname() const;
+  private:
+  bool _internal_has_displayname() const;
+  public:
+  void clear_displayname();
+  const std::string& displayname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displayname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displayname();
+  PROTOBUF_NODISCARD std::string* release_displayname();
+  void set_allocated_displayname(std::string* displayname);
+  private:
+  const std::string& _internal_displayname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value);
+  std::string* _internal_mutable_displayname();
+  public:
+
+  // optional string id = 2;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.Chat)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ContactMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactMessage) */ {
+ public:
+  inline Message_ContactMessage() : Message_ContactMessage(nullptr) {}
+  ~Message_ContactMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ContactMessage(const Message_ContactMessage& from);
+  Message_ContactMessage(Message_ContactMessage&& from) noexcept
+    : Message_ContactMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ContactMessage& operator=(const Message_ContactMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ContactMessage& operator=(Message_ContactMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ContactMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ContactMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ContactMessage*>(
+               &_Message_ContactMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    69;
+
+  friend void swap(Message_ContactMessage& a, Message_ContactMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ContactMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ContactMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ContactMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ContactMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ContactMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ContactMessage& from) {
+    Message_ContactMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ContactMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ContactMessage";
+  }
+  protected:
+  explicit Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayNameFieldNumber = 1,
+    kVcardFieldNumber = 16,
+    kContextInfoFieldNumber = 17,
+  };
+  // optional string displayName = 1;
+  bool has_displayname() const;
+  private:
+  bool _internal_has_displayname() const;
+  public:
+  void clear_displayname();
+  const std::string& displayname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displayname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displayname();
+  PROTOBUF_NODISCARD std::string* release_displayname();
+  void set_allocated_displayname(std::string* displayname);
+  private:
+  const std::string& _internal_displayname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value);
+  std::string* _internal_mutable_displayname();
+  public:
+
+  // optional string vcard = 16;
+  bool has_vcard() const;
+  private:
+  bool _internal_has_vcard() const;
+  public:
+  void clear_vcard();
+  const std::string& vcard() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_vcard(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_vcard();
+  PROTOBUF_NODISCARD std::string* release_vcard();
+  void set_allocated_vcard(std::string* vcard);
+  private:
+  const std::string& _internal_vcard() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vcard(const std::string& value);
+  std::string* _internal_mutable_vcard();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ContactMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vcard_;
+    ::proto::ContextInfo* contextinfo_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ContactsArrayMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactsArrayMessage) */ {
+ public:
+  inline Message_ContactsArrayMessage() : Message_ContactsArrayMessage(nullptr) {}
+  ~Message_ContactsArrayMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from);
+  Message_ContactsArrayMessage(Message_ContactsArrayMessage&& from) noexcept
+    : Message_ContactsArrayMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ContactsArrayMessage& operator=(const Message_ContactsArrayMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ContactsArrayMessage& operator=(Message_ContactsArrayMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ContactsArrayMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ContactsArrayMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ContactsArrayMessage*>(
+               &_Message_ContactsArrayMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    70;
+
+  friend void swap(Message_ContactsArrayMessage& a, Message_ContactsArrayMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ContactsArrayMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ContactsArrayMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ContactsArrayMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ContactsArrayMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ContactsArrayMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ContactsArrayMessage& from) {
+    Message_ContactsArrayMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ContactsArrayMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ContactsArrayMessage";
+  }
+  protected:
+  explicit Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContactsFieldNumber = 2,
+    kDisplayNameFieldNumber = 1,
+    kContextInfoFieldNumber = 17,
+  };
+  // repeated .proto.Message.ContactMessage contacts = 2;
+  int contacts_size() const;
+  private:
+  int _internal_contacts_size() const;
+  public:
+  void clear_contacts();
+  ::proto::Message_ContactMessage* mutable_contacts(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >*
+      mutable_contacts();
+  private:
+  const ::proto::Message_ContactMessage& _internal_contacts(int index) const;
+  ::proto::Message_ContactMessage* _internal_add_contacts();
+  public:
+  const ::proto::Message_ContactMessage& contacts(int index) const;
+  ::proto::Message_ContactMessage* add_contacts();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >&
+      contacts() const;
+
+  // optional string displayName = 1;
+  bool has_displayname() const;
+  private:
+  bool _internal_has_displayname() const;
+  public:
+  void clear_displayname();
+  const std::string& displayname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_displayname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_displayname();
+  PROTOBUF_NODISCARD std::string* release_displayname();
+  void set_allocated_displayname(std::string* displayname);
+  private:
+  const std::string& _internal_displayname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value);
+  std::string* _internal_mutable_displayname();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ContactsArrayMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage > contacts_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
+    ::proto::ContextInfo* contextinfo_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_DeclinePaymentRequestMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeclinePaymentRequestMessage) */ {
+ public:
+  inline Message_DeclinePaymentRequestMessage() : Message_DeclinePaymentRequestMessage(nullptr) {}
+  ~Message_DeclinePaymentRequestMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from);
+  Message_DeclinePaymentRequestMessage(Message_DeclinePaymentRequestMessage&& from) noexcept
+    : Message_DeclinePaymentRequestMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_DeclinePaymentRequestMessage& operator=(const Message_DeclinePaymentRequestMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_DeclinePaymentRequestMessage& operator=(Message_DeclinePaymentRequestMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_DeclinePaymentRequestMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_DeclinePaymentRequestMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_DeclinePaymentRequestMessage*>(
+               &_Message_DeclinePaymentRequestMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    71;
+
+  friend void swap(Message_DeclinePaymentRequestMessage& a, Message_DeclinePaymentRequestMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_DeclinePaymentRequestMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_DeclinePaymentRequestMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_DeclinePaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_DeclinePaymentRequestMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_DeclinePaymentRequestMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_DeclinePaymentRequestMessage& from) {
+    Message_DeclinePaymentRequestMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_DeclinePaymentRequestMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.DeclinePaymentRequestMessage";
+  }
+  protected:
+  explicit Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+  };
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.DeclinePaymentRequestMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* key_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_DeviceSentMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeviceSentMessage) */ {
+ public:
+  inline Message_DeviceSentMessage() : Message_DeviceSentMessage(nullptr) {}
+  ~Message_DeviceSentMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_DeviceSentMessage(const Message_DeviceSentMessage& from);
+  Message_DeviceSentMessage(Message_DeviceSentMessage&& from) noexcept
+    : Message_DeviceSentMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_DeviceSentMessage& operator=(const Message_DeviceSentMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_DeviceSentMessage& operator=(Message_DeviceSentMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_DeviceSentMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_DeviceSentMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_DeviceSentMessage*>(
+               &_Message_DeviceSentMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    72;
+
+  friend void swap(Message_DeviceSentMessage& a, Message_DeviceSentMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_DeviceSentMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_DeviceSentMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_DeviceSentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_DeviceSentMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_DeviceSentMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_DeviceSentMessage& from) {
+    Message_DeviceSentMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_DeviceSentMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.DeviceSentMessage";
+  }
+  protected:
+  explicit Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDestinationJidFieldNumber = 1,
+    kPhashFieldNumber = 3,
+    kMessageFieldNumber = 2,
+  };
+  // optional string destinationJid = 1;
+  bool has_destinationjid() const;
+  private:
+  bool _internal_has_destinationjid() const;
+  public:
+  void clear_destinationjid();
+  const std::string& destinationjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_destinationjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_destinationjid();
+  PROTOBUF_NODISCARD std::string* release_destinationjid();
+  void set_allocated_destinationjid(std::string* destinationjid);
+  private:
+  const std::string& _internal_destinationjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_destinationjid(const std::string& value);
+  std::string* _internal_mutable_destinationjid();
+  public:
+
+  // optional string phash = 3;
+  bool has_phash() const;
+  private:
+  bool _internal_has_phash() const;
+  public:
+  void clear_phash();
+  const std::string& phash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_phash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_phash();
+  PROTOBUF_NODISCARD std::string* release_phash();
+  void set_allocated_phash(std::string* phash);
+  private:
+  const std::string& _internal_phash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value);
+  std::string* _internal_mutable_phash();
+  public:
+
+  // optional .proto.Message message = 2;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const ::proto::Message& message() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_message();
+  ::proto::Message* mutable_message();
+  void set_allocated_message(::proto::Message* message);
+  private:
+  const ::proto::Message& _internal_message() const;
+  ::proto::Message* _internal_mutable_message();
+  public:
+  void unsafe_arena_set_allocated_message(
+      ::proto::Message* message);
+  ::proto::Message* unsafe_arena_release_message();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.DeviceSentMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destinationjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_;
+    ::proto::Message* message_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_DocumentMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DocumentMessage) */ {
+ public:
+  inline Message_DocumentMessage() : Message_DocumentMessage(nullptr) {}
+  ~Message_DocumentMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_DocumentMessage(const Message_DocumentMessage& from);
+  Message_DocumentMessage(Message_DocumentMessage&& from) noexcept
+    : Message_DocumentMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_DocumentMessage& operator=(const Message_DocumentMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_DocumentMessage& operator=(Message_DocumentMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_DocumentMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_DocumentMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_DocumentMessage*>(
+               &_Message_DocumentMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    73;
+
+  friend void swap(Message_DocumentMessage& a, Message_DocumentMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_DocumentMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_DocumentMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_DocumentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_DocumentMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_DocumentMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_DocumentMessage& from) {
+    Message_DocumentMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_DocumentMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.DocumentMessage";
+  }
+  protected:
+  explicit Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kMimetypeFieldNumber = 2,
+    kTitleFieldNumber = 3,
+    kFileSha256FieldNumber = 4,
+    kMediaKeyFieldNumber = 7,
+    kFileNameFieldNumber = 8,
+    kFileEncSha256FieldNumber = 9,
+    kDirectPathFieldNumber = 10,
+    kThumbnailDirectPathFieldNumber = 13,
+    kThumbnailSha256FieldNumber = 14,
+    kThumbnailEncSha256FieldNumber = 15,
+    kJpegThumbnailFieldNumber = 16,
+    kCaptionFieldNumber = 20,
+    kContextInfoFieldNumber = 17,
+    kFileLengthFieldNumber = 5,
+    kPageCountFieldNumber = 6,
+    kContactVcardFieldNumber = 12,
+    kMediaKeyTimestampFieldNumber = 11,
+    kThumbnailHeightFieldNumber = 18,
+    kThumbnailWidthFieldNumber = 19,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string mimetype = 2;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional string title = 3;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional bytes fileSha256 = 4;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes mediaKey = 7;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string fileName = 8;
+  bool has_filename() const;
+  private:
+  bool _internal_has_filename() const;
+  public:
+  void clear_filename();
+  const std::string& filename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filename();
+  PROTOBUF_NODISCARD std::string* release_filename();
+  void set_allocated_filename(std::string* filename);
+  private:
+  const std::string& _internal_filename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
+  std::string* _internal_mutable_filename();
+  public:
+
+  // optional bytes fileEncSha256 = 9;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 10;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional string thumbnailDirectPath = 13;
+  bool has_thumbnaildirectpath() const;
+  private:
+  bool _internal_has_thumbnaildirectpath() const;
+  public:
+  void clear_thumbnaildirectpath();
+  const std::string& thumbnaildirectpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnaildirectpath();
+  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
+  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
+  private:
+  const std::string& _internal_thumbnaildirectpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
+  std::string* _internal_mutable_thumbnaildirectpath();
+  public:
+
+  // optional bytes thumbnailSha256 = 14;
+  bool has_thumbnailsha256() const;
+  private:
+  bool _internal_has_thumbnailsha256() const;
+  public:
+  void clear_thumbnailsha256();
+  const std::string& thumbnailsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
+  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
+  private:
+  const std::string& _internal_thumbnailsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailsha256();
+  public:
+
+  // optional bytes thumbnailEncSha256 = 15;
+  bool has_thumbnailencsha256() const;
+  private:
+  bool _internal_has_thumbnailencsha256() const;
+  public:
+  void clear_thumbnailencsha256();
+  const std::string& thumbnailencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailencsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
+  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
+  private:
+  const std::string& _internal_thumbnailencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailencsha256();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional string caption = 20;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint64 fileLength = 5;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional uint32 pageCount = 6;
+  bool has_pagecount() const;
+  private:
+  bool _internal_has_pagecount() const;
+  public:
+  void clear_pagecount();
+  uint32_t pagecount() const;
+  void set_pagecount(uint32_t value);
+  private:
+  uint32_t _internal_pagecount() const;
+  void _internal_set_pagecount(uint32_t value);
+  public:
+
+  // optional bool contactVcard = 12;
+  bool has_contactvcard() const;
+  private:
+  bool _internal_has_contactvcard() const;
+  public:
+  void clear_contactvcard();
+  bool contactvcard() const;
+  void set_contactvcard(bool value);
+  private:
+  bool _internal_contactvcard() const;
+  void _internal_set_contactvcard(bool value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 11;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // optional uint32 thumbnailHeight = 18;
+  bool has_thumbnailheight() const;
+  private:
+  bool _internal_has_thumbnailheight() const;
+  public:
+  void clear_thumbnailheight();
+  uint32_t thumbnailheight() const;
+  void set_thumbnailheight(uint32_t value);
+  private:
+  uint32_t _internal_thumbnailheight() const;
+  void _internal_set_thumbnailheight(uint32_t value);
+  public:
+
+  // optional uint32 thumbnailWidth = 19;
+  bool has_thumbnailwidth() const;
+  private:
+  bool _internal_has_thumbnailwidth() const;
+  public:
+  void clear_thumbnailwidth();
+  uint32_t thumbnailwidth() const;
+  void set_thumbnailwidth(uint32_t value);
+  private:
+  uint32_t _internal_thumbnailwidth() const;
+  void _internal_set_thumbnailwidth(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.DocumentMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::proto::ContextInfo* contextinfo_;
+    uint64_t filelength_;
+    uint32_t pagecount_;
+    bool contactvcard_;
+    int64_t mediakeytimestamp_;
+    uint32_t thumbnailheight_;
+    uint32_t thumbnailwidth_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ExtendedTextMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ExtendedTextMessage) */ {
+ public:
+  inline Message_ExtendedTextMessage() : Message_ExtendedTextMessage(nullptr) {}
+  ~Message_ExtendedTextMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from);
+  Message_ExtendedTextMessage(Message_ExtendedTextMessage&& from) noexcept
+    : Message_ExtendedTextMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ExtendedTextMessage& operator=(const Message_ExtendedTextMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ExtendedTextMessage& operator=(Message_ExtendedTextMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ExtendedTextMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ExtendedTextMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ExtendedTextMessage*>(
+               &_Message_ExtendedTextMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    74;
+
+  friend void swap(Message_ExtendedTextMessage& a, Message_ExtendedTextMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ExtendedTextMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ExtendedTextMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ExtendedTextMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ExtendedTextMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ExtendedTextMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ExtendedTextMessage& from) {
+    Message_ExtendedTextMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ExtendedTextMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ExtendedTextMessage";
+  }
+  protected:
+  explicit Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ExtendedTextMessage_FontType FontType;
+  static constexpr FontType SANS_SERIF =
+    Message_ExtendedTextMessage_FontType_SANS_SERIF;
+  static constexpr FontType SERIF =
+    Message_ExtendedTextMessage_FontType_SERIF;
+  static constexpr FontType NORICAN_REGULAR =
+    Message_ExtendedTextMessage_FontType_NORICAN_REGULAR;
+  static constexpr FontType BRYNDAN_WRITE =
+    Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE;
+  static constexpr FontType BEBASNEUE_REGULAR =
+    Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR;
+  static constexpr FontType OSWALD_HEAVY =
+    Message_ExtendedTextMessage_FontType_OSWALD_HEAVY;
+  static inline bool FontType_IsValid(int value) {
+    return Message_ExtendedTextMessage_FontType_IsValid(value);
+  }
+  static constexpr FontType FontType_MIN =
+    Message_ExtendedTextMessage_FontType_FontType_MIN;
+  static constexpr FontType FontType_MAX =
+    Message_ExtendedTextMessage_FontType_FontType_MAX;
+  static constexpr int FontType_ARRAYSIZE =
+    Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  FontType_descriptor() {
+    return Message_ExtendedTextMessage_FontType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& FontType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, FontType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function FontType_Name.");
+    return Message_ExtendedTextMessage_FontType_Name(enum_t_value);
+  }
+  static inline bool FontType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      FontType* value) {
+    return Message_ExtendedTextMessage_FontType_Parse(name, value);
+  }
+
+  typedef Message_ExtendedTextMessage_InviteLinkGroupType InviteLinkGroupType;
+  static constexpr InviteLinkGroupType DEFAULT =
+    Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT;
+  static constexpr InviteLinkGroupType PARENT =
+    Message_ExtendedTextMessage_InviteLinkGroupType_PARENT;
+  static constexpr InviteLinkGroupType SUB =
+    Message_ExtendedTextMessage_InviteLinkGroupType_SUB;
+  static constexpr InviteLinkGroupType DEFAULT_SUB =
+    Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB;
+  static inline bool InviteLinkGroupType_IsValid(int value) {
+    return Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value);
+  }
+  static constexpr InviteLinkGroupType InviteLinkGroupType_MIN =
+    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN;
+  static constexpr InviteLinkGroupType InviteLinkGroupType_MAX =
+    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX;
+  static constexpr int InviteLinkGroupType_ARRAYSIZE =
+    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  InviteLinkGroupType_descriptor() {
+    return Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& InviteLinkGroupType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, InviteLinkGroupType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function InviteLinkGroupType_Name.");
+    return Message_ExtendedTextMessage_InviteLinkGroupType_Name(enum_t_value);
+  }
+  static inline bool InviteLinkGroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      InviteLinkGroupType* value) {
+    return Message_ExtendedTextMessage_InviteLinkGroupType_Parse(name, value);
+  }
+
+  typedef Message_ExtendedTextMessage_PreviewType PreviewType;
+  static constexpr PreviewType NONE =
+    Message_ExtendedTextMessage_PreviewType_NONE;
+  static constexpr PreviewType VIDEO =
+    Message_ExtendedTextMessage_PreviewType_VIDEO;
+  static inline bool PreviewType_IsValid(int value) {
+    return Message_ExtendedTextMessage_PreviewType_IsValid(value);
+  }
+  static constexpr PreviewType PreviewType_MIN =
+    Message_ExtendedTextMessage_PreviewType_PreviewType_MIN;
+  static constexpr PreviewType PreviewType_MAX =
+    Message_ExtendedTextMessage_PreviewType_PreviewType_MAX;
+  static constexpr int PreviewType_ARRAYSIZE =
+    Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  PreviewType_descriptor() {
+    return Message_ExtendedTextMessage_PreviewType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& PreviewType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, PreviewType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function PreviewType_Name.");
+    return Message_ExtendedTextMessage_PreviewType_Name(enum_t_value);
+  }
+  static inline bool PreviewType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      PreviewType* value) {
+    return Message_ExtendedTextMessage_PreviewType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 1,
+    kMatchedTextFieldNumber = 2,
+    kCanonicalUrlFieldNumber = 4,
+    kDescriptionFieldNumber = 5,
+    kTitleFieldNumber = 6,
+    kJpegThumbnailFieldNumber = 16,
+    kThumbnailDirectPathFieldNumber = 19,
+    kThumbnailSha256FieldNumber = 20,
+    kThumbnailEncSha256FieldNumber = 21,
+    kMediaKeyFieldNumber = 22,
+    kInviteLinkParentGroupSubjectV2FieldNumber = 27,
+    kInviteLinkParentGroupThumbnailV2FieldNumber = 28,
+    kContextInfoFieldNumber = 17,
+    kTextArgbFieldNumber = 7,
+    kBackgroundArgbFieldNumber = 8,
+    kFontFieldNumber = 9,
+    kPreviewTypeFieldNumber = 10,
+    kDoNotPlayInlineFieldNumber = 18,
+    kThumbnailHeightFieldNumber = 24,
+    kMediaKeyTimestampFieldNumber = 23,
+    kThumbnailWidthFieldNumber = 25,
+    kInviteLinkGroupTypeFieldNumber = 26,
+    kInviteLinkGroupTypeV2FieldNumber = 29,
+  };
+  // optional string text = 1;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // optional string matchedText = 2;
+  bool has_matchedtext() const;
+  private:
+  bool _internal_has_matchedtext() const;
+  public:
+  void clear_matchedtext();
+  const std::string& matchedtext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_matchedtext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_matchedtext();
+  PROTOBUF_NODISCARD std::string* release_matchedtext();
+  void set_allocated_matchedtext(std::string* matchedtext);
+  private:
+  const std::string& _internal_matchedtext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value);
+  std::string* _internal_mutable_matchedtext();
+  public:
+
+  // optional string canonicalUrl = 4;
+  bool has_canonicalurl() const;
+  private:
+  bool _internal_has_canonicalurl() const;
+  public:
+  void clear_canonicalurl();
+  const std::string& canonicalurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_canonicalurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_canonicalurl();
+  PROTOBUF_NODISCARD std::string* release_canonicalurl();
+  void set_allocated_canonicalurl(std::string* canonicalurl);
+  private:
+  const std::string& _internal_canonicalurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value);
+  std::string* _internal_mutable_canonicalurl();
+  public:
+
+  // optional string description = 5;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string title = 6;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional string thumbnailDirectPath = 19;
+  bool has_thumbnaildirectpath() const;
+  private:
+  bool _internal_has_thumbnaildirectpath() const;
+  public:
+  void clear_thumbnaildirectpath();
+  const std::string& thumbnaildirectpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnaildirectpath();
+  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
+  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
+  private:
+  const std::string& _internal_thumbnaildirectpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
+  std::string* _internal_mutable_thumbnaildirectpath();
+  public:
+
+  // optional bytes thumbnailSha256 = 20;
+  bool has_thumbnailsha256() const;
+  private:
+  bool _internal_has_thumbnailsha256() const;
+  public:
+  void clear_thumbnailsha256();
+  const std::string& thumbnailsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
+  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
+  private:
+  const std::string& _internal_thumbnailsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailsha256();
+  public:
+
+  // optional bytes thumbnailEncSha256 = 21;
+  bool has_thumbnailencsha256() const;
+  private:
+  bool _internal_has_thumbnailencsha256() const;
+  public:
+  void clear_thumbnailencsha256();
+  const std::string& thumbnailencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailencsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
+  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
+  private:
+  const std::string& _internal_thumbnailencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailencsha256();
+  public:
+
+  // optional bytes mediaKey = 22;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string inviteLinkParentGroupSubjectV2 = 27;
+  bool has_invitelinkparentgroupsubjectv2() const;
+  private:
+  bool _internal_has_invitelinkparentgroupsubjectv2() const;
+  public:
+  void clear_invitelinkparentgroupsubjectv2();
+  const std::string& invitelinkparentgroupsubjectv2() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_invitelinkparentgroupsubjectv2();
+  PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupsubjectv2();
+  void set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2);
+  private:
+  const std::string& _internal_invitelinkparentgroupsubjectv2() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupsubjectv2(const std::string& value);
+  std::string* _internal_mutable_invitelinkparentgroupsubjectv2();
+  public:
+
+  // optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+  bool has_invitelinkparentgroupthumbnailv2() const;
+  private:
+  bool _internal_has_invitelinkparentgroupthumbnailv2() const;
+  public:
+  void clear_invitelinkparentgroupthumbnailv2();
+  const std::string& invitelinkparentgroupthumbnailv2() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_invitelinkparentgroupthumbnailv2();
+  PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupthumbnailv2();
+  void set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2);
+  private:
+  const std::string& _internal_invitelinkparentgroupthumbnailv2() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupthumbnailv2(const std::string& value);
+  std::string* _internal_mutable_invitelinkparentgroupthumbnailv2();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional fixed32 textArgb = 7;
+  bool has_textargb() const;
+  private:
+  bool _internal_has_textargb() const;
+  public:
+  void clear_textargb();
+  uint32_t textargb() const;
+  void set_textargb(uint32_t value);
+  private:
+  uint32_t _internal_textargb() const;
+  void _internal_set_textargb(uint32_t value);
+  public:
+
+  // optional fixed32 backgroundArgb = 8;
+  bool has_backgroundargb() const;
+  private:
+  bool _internal_has_backgroundargb() const;
+  public:
+  void clear_backgroundargb();
+  uint32_t backgroundargb() const;
+  void set_backgroundargb(uint32_t value);
+  private:
+  uint32_t _internal_backgroundargb() const;
+  void _internal_set_backgroundargb(uint32_t value);
+  public:
+
+  // optional .proto.Message.ExtendedTextMessage.FontType font = 9;
+  bool has_font() const;
+  private:
+  bool _internal_has_font() const;
+  public:
+  void clear_font();
+  ::proto::Message_ExtendedTextMessage_FontType font() const;
+  void set_font(::proto::Message_ExtendedTextMessage_FontType value);
+  private:
+  ::proto::Message_ExtendedTextMessage_FontType _internal_font() const;
+  void _internal_set_font(::proto::Message_ExtendedTextMessage_FontType value);
+  public:
+
+  // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
+  bool has_previewtype() const;
+  private:
+  bool _internal_has_previewtype() const;
+  public:
+  void clear_previewtype();
+  ::proto::Message_ExtendedTextMessage_PreviewType previewtype() const;
+  void set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value);
+  private:
+  ::proto::Message_ExtendedTextMessage_PreviewType _internal_previewtype() const;
+  void _internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value);
+  public:
+
+  // optional bool doNotPlayInline = 18;
+  bool has_donotplayinline() const;
+  private:
+  bool _internal_has_donotplayinline() const;
+  public:
+  void clear_donotplayinline();
+  bool donotplayinline() const;
+  void set_donotplayinline(bool value);
+  private:
+  bool _internal_donotplayinline() const;
+  void _internal_set_donotplayinline(bool value);
+  public:
+
+  // optional uint32 thumbnailHeight = 24;
+  bool has_thumbnailheight() const;
+  private:
+  bool _internal_has_thumbnailheight() const;
+  public:
+  void clear_thumbnailheight();
+  uint32_t thumbnailheight() const;
+  void set_thumbnailheight(uint32_t value);
+  private:
+  uint32_t _internal_thumbnailheight() const;
+  void _internal_set_thumbnailheight(uint32_t value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 23;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // optional uint32 thumbnailWidth = 25;
+  bool has_thumbnailwidth() const;
+  private:
+  bool _internal_has_thumbnailwidth() const;
+  public:
+  void clear_thumbnailwidth();
+  uint32_t thumbnailwidth() const;
+  void set_thumbnailwidth(uint32_t value);
+  private:
+  uint32_t _internal_thumbnailwidth() const;
+  void _internal_set_thumbnailwidth(uint32_t value);
+  public:
+
+  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
+  bool has_invitelinkgrouptype() const;
+  private:
+  bool _internal_has_invitelinkgrouptype() const;
+  public:
+  void clear_invitelinkgrouptype();
+  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptype() const;
+  void set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
+  private:
+  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptype() const;
+  void _internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
+  public:
+
+  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+  bool has_invitelinkgrouptypev2() const;
+  private:
+  bool _internal_has_invitelinkgrouptypev2() const;
+  public:
+  void clear_invitelinkgrouptypev2();
+  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptypev2() const;
+  void set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
+  private:
+  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptypev2() const;
+  void _internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ExtendedTextMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupsubjectv2_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupthumbnailv2_;
+    ::proto::ContextInfo* contextinfo_;
+    uint32_t textargb_;
+    uint32_t backgroundargb_;
+    int font_;
+    int previewtype_;
+    bool donotplayinline_;
+    uint32_t thumbnailheight_;
+    int64_t mediakeytimestamp_;
+    uint32_t thumbnailwidth_;
+    int invitelinkgrouptype_;
+    int invitelinkgrouptypev2_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_FutureProofMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.FutureProofMessage) */ {
+ public:
+  inline Message_FutureProofMessage() : Message_FutureProofMessage(nullptr) {}
+  ~Message_FutureProofMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_FutureProofMessage(const Message_FutureProofMessage& from);
+  Message_FutureProofMessage(Message_FutureProofMessage&& from) noexcept
+    : Message_FutureProofMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_FutureProofMessage& operator=(const Message_FutureProofMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_FutureProofMessage& operator=(Message_FutureProofMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_FutureProofMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_FutureProofMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_FutureProofMessage*>(
+               &_Message_FutureProofMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    75;
+
+  friend void swap(Message_FutureProofMessage& a, Message_FutureProofMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_FutureProofMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_FutureProofMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_FutureProofMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_FutureProofMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_FutureProofMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_FutureProofMessage& from) {
+    Message_FutureProofMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_FutureProofMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.FutureProofMessage";
+  }
+  protected:
+  explicit Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageFieldNumber = 1,
+  };
+  // optional .proto.Message message = 1;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const ::proto::Message& message() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_message();
+  ::proto::Message* mutable_message();
+  void set_allocated_message(::proto::Message* message);
+  private:
+  const ::proto::Message& _internal_message() const;
+  ::proto::Message* _internal_mutable_message();
+  public:
+  void unsafe_arena_set_allocated_message(
+      ::proto::Message* message);
+  ::proto::Message* unsafe_arena_release_message();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.FutureProofMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message* message_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_GroupInviteMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.GroupInviteMessage) */ {
+ public:
+  inline Message_GroupInviteMessage() : Message_GroupInviteMessage(nullptr) {}
+  ~Message_GroupInviteMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_GroupInviteMessage(const Message_GroupInviteMessage& from);
+  Message_GroupInviteMessage(Message_GroupInviteMessage&& from) noexcept
+    : Message_GroupInviteMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_GroupInviteMessage& operator=(const Message_GroupInviteMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_GroupInviteMessage& operator=(Message_GroupInviteMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_GroupInviteMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_GroupInviteMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_GroupInviteMessage*>(
+               &_Message_GroupInviteMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    76;
+
+  friend void swap(Message_GroupInviteMessage& a, Message_GroupInviteMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_GroupInviteMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_GroupInviteMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_GroupInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_GroupInviteMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_GroupInviteMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_GroupInviteMessage& from) {
+    Message_GroupInviteMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_GroupInviteMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.GroupInviteMessage";
+  }
+  protected:
+  explicit Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_GroupInviteMessage_GroupType GroupType;
+  static constexpr GroupType DEFAULT =
+    Message_GroupInviteMessage_GroupType_DEFAULT;
+  static constexpr GroupType PARENT =
+    Message_GroupInviteMessage_GroupType_PARENT;
+  static inline bool GroupType_IsValid(int value) {
+    return Message_GroupInviteMessage_GroupType_IsValid(value);
+  }
+  static constexpr GroupType GroupType_MIN =
+    Message_GroupInviteMessage_GroupType_GroupType_MIN;
+  static constexpr GroupType GroupType_MAX =
+    Message_GroupInviteMessage_GroupType_GroupType_MAX;
+  static constexpr int GroupType_ARRAYSIZE =
+    Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  GroupType_descriptor() {
+    return Message_GroupInviteMessage_GroupType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& GroupType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, GroupType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function GroupType_Name.");
+    return Message_GroupInviteMessage_GroupType_Name(enum_t_value);
+  }
+  static inline bool GroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      GroupType* value) {
+    return Message_GroupInviteMessage_GroupType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupJidFieldNumber = 1,
+    kInviteCodeFieldNumber = 2,
+    kGroupNameFieldNumber = 4,
+    kJpegThumbnailFieldNumber = 5,
+    kCaptionFieldNumber = 6,
+    kContextInfoFieldNumber = 7,
+    kInviteExpirationFieldNumber = 3,
+    kGroupTypeFieldNumber = 8,
+  };
+  // optional string groupJid = 1;
+  bool has_groupjid() const;
+  private:
+  bool _internal_has_groupjid() const;
+  public:
+  void clear_groupjid();
+  const std::string& groupjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupjid();
+  PROTOBUF_NODISCARD std::string* release_groupjid();
+  void set_allocated_groupjid(std::string* groupjid);
+  private:
+  const std::string& _internal_groupjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value);
+  std::string* _internal_mutable_groupjid();
+  public:
+
+  // optional string inviteCode = 2;
+  bool has_invitecode() const;
+  private:
+  bool _internal_has_invitecode() const;
+  public:
+  void clear_invitecode();
+  const std::string& invitecode() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_invitecode(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_invitecode();
+  PROTOBUF_NODISCARD std::string* release_invitecode();
+  void set_allocated_invitecode(std::string* invitecode);
+  private:
+  const std::string& _internal_invitecode() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitecode(const std::string& value);
+  std::string* _internal_mutable_invitecode();
+  public:
+
+  // optional string groupName = 4;
+  bool has_groupname() const;
+  private:
+  bool _internal_has_groupname() const;
+  public:
+  void clear_groupname();
+  const std::string& groupname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupname();
+  PROTOBUF_NODISCARD std::string* release_groupname();
+  void set_allocated_groupname(std::string* groupname);
+  private:
+  const std::string& _internal_groupname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupname(const std::string& value);
+  std::string* _internal_mutable_groupname();
+  public:
+
+  // optional bytes jpegThumbnail = 5;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional string caption = 6;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 7;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional int64 inviteExpiration = 3;
+  bool has_inviteexpiration() const;
+  private:
+  bool _internal_has_inviteexpiration() const;
+  public:
+  void clear_inviteexpiration();
+  int64_t inviteexpiration() const;
+  void set_inviteexpiration(int64_t value);
+  private:
+  int64_t _internal_inviteexpiration() const;
+  void _internal_set_inviteexpiration(int64_t value);
+  public:
+
+  // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
+  bool has_grouptype() const;
+  private:
+  bool _internal_has_grouptype() const;
+  public:
+  void clear_grouptype();
+  ::proto::Message_GroupInviteMessage_GroupType grouptype() const;
+  void set_grouptype(::proto::Message_GroupInviteMessage_GroupType value);
+  private:
+  ::proto::Message_GroupInviteMessage_GroupType _internal_grouptype() const;
+  void _internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.GroupInviteMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitecode_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::proto::ContextInfo* contextinfo_;
+    int64_t inviteexpiration_;
+    int grouptype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) */ {
+ public:
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(nullptr) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from);
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept
+    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency*>(
+               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    77;
+
+  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCurrencyCodeFieldNumber = 1,
+    kAmount1000FieldNumber = 2,
+  };
+  // optional string currencyCode = 1;
+  bool has_currencycode() const;
+  private:
+  bool _internal_has_currencycode() const;
+  public:
+  void clear_currencycode();
+  const std::string& currencycode() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_currencycode(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_currencycode();
+  PROTOBUF_NODISCARD std::string* release_currencycode();
+  void set_allocated_currencycode(std::string* currencycode);
+  private:
+  const std::string& _internal_currencycode() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
+  std::string* _internal_mutable_currencycode();
+  public:
+
+  // optional int64 amount1000 = 2;
+  bool has_amount1000() const;
+  private:
+  bool _internal_has_amount1000() const;
+  public:
+  void clear_amount1000();
+  int64_t amount1000() const;
+  void set_amount1000(int64_t value);
+  private:
+  int64_t _internal_amount1000() const;
+  void _internal_set_amount1000(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_;
+    int64_t amount1000_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) */ {
+ public:
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(nullptr) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from);
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept
+    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent*>(
+               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    78;
+
+  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType CalendarType;
+  static constexpr CalendarType GREGORIAN =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN;
+  static constexpr CalendarType SOLAR_HIJRI =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI;
+  static inline bool CalendarType_IsValid(int value) {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value);
+  }
+  static constexpr CalendarType CalendarType_MIN =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN;
+  static constexpr CalendarType CalendarType_MAX =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX;
+  static constexpr int CalendarType_ARRAYSIZE =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CalendarType_descriptor() {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CalendarType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CalendarType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CalendarType_Name.");
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(enum_t_value);
+  }
+  static inline bool CalendarType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CalendarType* value) {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(name, value);
+  }
+
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType DayOfWeekType;
+  static constexpr DayOfWeekType MONDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY;
+  static constexpr DayOfWeekType TUESDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY;
+  static constexpr DayOfWeekType WEDNESDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY;
+  static constexpr DayOfWeekType THURSDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY;
+  static constexpr DayOfWeekType FRIDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY;
+  static constexpr DayOfWeekType SATURDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY;
+  static constexpr DayOfWeekType SUNDAY =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY;
+  static inline bool DayOfWeekType_IsValid(int value) {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value);
+  }
+  static constexpr DayOfWeekType DayOfWeekType_MIN =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN;
+  static constexpr DayOfWeekType DayOfWeekType_MAX =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX;
+  static constexpr int DayOfWeekType_ARRAYSIZE =
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DayOfWeekType_descriptor() {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DayOfWeekType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DayOfWeekType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DayOfWeekType_Name.");
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(enum_t_value);
+  }
+  static inline bool DayOfWeekType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DayOfWeekType* value) {
+    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kYearFieldNumber = 2,
+    kMonthFieldNumber = 3,
+    kDayOfMonthFieldNumber = 4,
+    kHourFieldNumber = 5,
+    kMinuteFieldNumber = 6,
+    kDayOfWeekFieldNumber = 1,
+    kCalendarFieldNumber = 7,
+  };
+  // optional uint32 year = 2;
+  bool has_year() const;
+  private:
+  bool _internal_has_year() const;
+  public:
+  void clear_year();
+  uint32_t year() const;
+  void set_year(uint32_t value);
+  private:
+  uint32_t _internal_year() const;
+  void _internal_set_year(uint32_t value);
+  public:
+
+  // optional uint32 month = 3;
+  bool has_month() const;
+  private:
+  bool _internal_has_month() const;
+  public:
+  void clear_month();
+  uint32_t month() const;
+  void set_month(uint32_t value);
+  private:
+  uint32_t _internal_month() const;
+  void _internal_set_month(uint32_t value);
+  public:
+
+  // optional uint32 dayOfMonth = 4;
+  bool has_dayofmonth() const;
+  private:
+  bool _internal_has_dayofmonth() const;
+  public:
+  void clear_dayofmonth();
+  uint32_t dayofmonth() const;
+  void set_dayofmonth(uint32_t value);
+  private:
+  uint32_t _internal_dayofmonth() const;
+  void _internal_set_dayofmonth(uint32_t value);
+  public:
+
+  // optional uint32 hour = 5;
+  bool has_hour() const;
+  private:
+  bool _internal_has_hour() const;
+  public:
+  void clear_hour();
+  uint32_t hour() const;
+  void set_hour(uint32_t value);
+  private:
+  uint32_t _internal_hour() const;
+  void _internal_set_hour(uint32_t value);
+  public:
+
+  // optional uint32 minute = 6;
+  bool has_minute() const;
+  private:
+  bool _internal_has_minute() const;
+  public:
+  void clear_minute();
+  uint32_t minute() const;
+  void set_minute(uint32_t value);
+  private:
+  uint32_t _internal_minute() const;
+  void _internal_set_minute(uint32_t value);
+  public:
+
+  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
+  bool has_dayofweek() const;
+  private:
+  bool _internal_has_dayofweek() const;
+  public:
+  void clear_dayofweek();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType dayofweek() const;
+  void set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value);
+  private:
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType _internal_dayofweek() const;
+  void _internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value);
+  public:
+
+  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
+  bool has_calendar() const;
+  private:
+  bool _internal_has_calendar() const;
+  public:
+  void clear_calendar();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType calendar() const;
+  void set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value);
+  private:
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType _internal_calendar() const;
+  void _internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t year_;
+    uint32_t month_;
+    uint32_t dayofmonth_;
+    uint32_t hour_;
+    uint32_t minute_;
+    int dayofweek_;
+    int calendar_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) */ {
+ public:
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(nullptr) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from);
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept
+    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch*>(
+               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    79;
+
+  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTimestampFieldNumber = 1,
+  };
+  // optional int64 timestamp = 1;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t timestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) */ {
+ public:
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(nullptr) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from);
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept
+    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& default_instance() {
+    return *internal_default_instance();
+  }
+  enum DatetimeOneofCase {
+    kComponent = 1,
+    kUnixEpoch = 2,
+    DATETIMEONEOF_NOT_SET = 0,
+  };
+
+  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime*>(
+               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    80;
+
+  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent HSMDateTimeComponent;
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch HSMDateTimeUnixEpoch;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kComponentFieldNumber = 1,
+    kUnixEpochFieldNumber = 2,
+  };
+  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
+  bool has_component() const;
+  private:
+  bool _internal_has_component() const;
+  public:
+  void clear_component();
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* release_component();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* mutable_component();
+  void set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component);
+  private:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& _internal_component() const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _internal_mutable_component();
+  public:
+  void unsafe_arena_set_allocated_component(
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component);
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* unsafe_arena_release_component();
+
+  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
+  bool has_unixepoch() const;
+  private:
+  bool _internal_has_unixepoch() const;
+  public:
+  void clear_unixepoch();
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* release_unixepoch();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* mutable_unixepoch();
+  void set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch);
+  private:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& _internal_unixepoch() const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _internal_mutable_unixepoch();
+  public:
+  void unsafe_arena_set_allocated_unixepoch(
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch);
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unsafe_arena_release_unixepoch();
+
+  void clear_datetimeOneof();
+  DatetimeOneofCase datetimeOneof_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
+ private:
+  class _Internal;
+  void set_has_component();
+  void set_has_unixepoch();
+
+  inline bool has_datetimeOneof() const;
+  inline void clear_has_datetimeOneof();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union DatetimeOneofUnion {
+      constexpr DatetimeOneofUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component_;
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch_;
+    } datetimeOneof_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage_HSMLocalizableParameter final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) */ {
+ public:
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter() : Message_HighlyStructuredMessage_HSMLocalizableParameter(nullptr) {}
+  ~Message_HighlyStructuredMessage_HSMLocalizableParameter() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from);
+  Message_HighlyStructuredMessage_HSMLocalizableParameter(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept
+    : Message_HighlyStructuredMessage_HSMLocalizableParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage_HSMLocalizableParameter& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ParamOneofCase {
+    kCurrency = 2,
+    kDateTime = 3,
+    PARAMONEOF_NOT_SET = 0,
+  };
+
+  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter*>(
+               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    81;
+
+  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter& a, Message_HighlyStructuredMessage_HSMLocalizableParameter& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage_HSMLocalizableParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) {
+    Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency HSMCurrency;
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime HSMDateTime;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDefaultFieldNumber = 1,
+    kCurrencyFieldNumber = 2,
+    kDateTimeFieldNumber = 3,
+  };
+  // optional string default = 1;
+  bool has_default_() const;
+  private:
+  bool _internal_has_default_() const;
+  public:
+  void clear_default_();
+  const std::string& default_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_default_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_default_();
+  PROTOBUF_NODISCARD std::string* release_default_();
+  void set_allocated_default_(std::string* default_);
+  private:
+  const std::string& _internal_default_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_(const std::string& value);
+  std::string* _internal_mutable_default_();
+  public:
+
+  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
+  bool has_currency() const;
+  private:
+  bool _internal_has_currency() const;
+  public:
+  void clear_currency();
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* release_currency();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* mutable_currency();
+  void set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency);
+  private:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& _internal_currency() const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _internal_mutable_currency();
+  public:
+  void unsafe_arena_set_allocated_currency(
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency);
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* unsafe_arena_release_currency();
+
+  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
+  bool has_datetime() const;
+  private:
+  bool _internal_has_datetime() const;
+  public:
+  void clear_datetime();
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* release_datetime();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* mutable_datetime();
+  void set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime);
+  private:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& _internal_datetime() const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _internal_mutable_datetime();
+  public:
+  void unsafe_arena_set_allocated_datetime(
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime);
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* unsafe_arena_release_datetime();
+
+  void clear_paramOneof();
+  ParamOneofCase paramOneof_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
+ private:
+  class _Internal;
+  void set_has_currency();
+  void set_has_datetime();
+
+  inline bool has_paramOneof() const;
+  inline void clear_has_paramOneof();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default__;
+    union ParamOneofUnion {
+      constexpr ParamOneofUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency_;
+      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime_;
+    } paramOneof_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HighlyStructuredMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage) */ {
+ public:
+  inline Message_HighlyStructuredMessage() : Message_HighlyStructuredMessage(nullptr) {}
+  ~Message_HighlyStructuredMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from);
+  Message_HighlyStructuredMessage(Message_HighlyStructuredMessage&& from) noexcept
+    : Message_HighlyStructuredMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HighlyStructuredMessage& operator=(const Message_HighlyStructuredMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HighlyStructuredMessage& operator=(Message_HighlyStructuredMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HighlyStructuredMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_HighlyStructuredMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_HighlyStructuredMessage*>(
+               &_Message_HighlyStructuredMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    82;
+
+  friend void swap(Message_HighlyStructuredMessage& a, Message_HighlyStructuredMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HighlyStructuredMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HighlyStructuredMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HighlyStructuredMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HighlyStructuredMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HighlyStructuredMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HighlyStructuredMessage& from) {
+    Message_HighlyStructuredMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HighlyStructuredMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HighlyStructuredMessage";
+  }
+  protected:
+  explicit Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter HSMLocalizableParameter;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kParamsFieldNumber = 3,
+    kLocalizableParamsFieldNumber = 6,
+    kNamespaceFieldNumber = 1,
+    kElementNameFieldNumber = 2,
+    kFallbackLgFieldNumber = 4,
+    kFallbackLcFieldNumber = 5,
+    kDeterministicLgFieldNumber = 7,
+    kDeterministicLcFieldNumber = 8,
+    kHydratedHsmFieldNumber = 9,
+  };
+  // repeated string params = 3;
+  int params_size() const;
+  private:
+  int _internal_params_size() const;
+  public:
+  void clear_params();
+  const std::string& params(int index) const;
+  std::string* mutable_params(int index);
+  void set_params(int index, const std::string& value);
+  void set_params(int index, std::string&& value);
+  void set_params(int index, const char* value);
+  void set_params(int index, const char* value, size_t size);
+  std::string* add_params();
+  void add_params(const std::string& value);
+  void add_params(std::string&& value);
+  void add_params(const char* value);
+  void add_params(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& params() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_params();
+  private:
+  const std::string& _internal_params(int index) const;
+  std::string* _internal_add_params();
+  public:
+
+  // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
+  int localizableparams_size() const;
+  private:
+  int _internal_localizableparams_size() const;
+  public:
+  void clear_localizableparams();
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* mutable_localizableparams(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >*
+      mutable_localizableparams();
+  private:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& _internal_localizableparams(int index) const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _internal_add_localizableparams();
+  public:
+  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& localizableparams(int index) const;
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* add_localizableparams();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >&
+      localizableparams() const;
+
+  // optional string namespace = 1;
+  bool has_namespace_() const;
+  private:
+  bool _internal_has_namespace_() const;
+  public:
+  void clear_namespace_();
+  const std::string& namespace_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_namespace_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_namespace_();
+  PROTOBUF_NODISCARD std::string* release_namespace_();
+  void set_allocated_namespace_(std::string* namespace_);
+  private:
+  const std::string& _internal_namespace_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
+  std::string* _internal_mutable_namespace_();
+  public:
+
+  // optional string elementName = 2;
+  bool has_elementname() const;
+  private:
+  bool _internal_has_elementname() const;
+  public:
+  void clear_elementname();
+  const std::string& elementname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_elementname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_elementname();
+  PROTOBUF_NODISCARD std::string* release_elementname();
+  void set_allocated_elementname(std::string* elementname);
+  private:
+  const std::string& _internal_elementname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_elementname(const std::string& value);
+  std::string* _internal_mutable_elementname();
+  public:
+
+  // optional string fallbackLg = 4;
+  bool has_fallbacklg() const;
+  private:
+  bool _internal_has_fallbacklg() const;
+  public:
+  void clear_fallbacklg();
+  const std::string& fallbacklg() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fallbacklg(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fallbacklg();
+  PROTOBUF_NODISCARD std::string* release_fallbacklg();
+  void set_allocated_fallbacklg(std::string* fallbacklg);
+  private:
+  const std::string& _internal_fallbacklg() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklg(const std::string& value);
+  std::string* _internal_mutable_fallbacklg();
+  public:
+
+  // optional string fallbackLc = 5;
+  bool has_fallbacklc() const;
+  private:
+  bool _internal_has_fallbacklc() const;
+  public:
+  void clear_fallbacklc();
+  const std::string& fallbacklc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fallbacklc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fallbacklc();
+  PROTOBUF_NODISCARD std::string* release_fallbacklc();
+  void set_allocated_fallbacklc(std::string* fallbacklc);
+  private:
+  const std::string& _internal_fallbacklc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklc(const std::string& value);
+  std::string* _internal_mutable_fallbacklc();
+  public:
+
+  // optional string deterministicLg = 7;
+  bool has_deterministiclg() const;
+  private:
+  bool _internal_has_deterministiclg() const;
+  public:
+  void clear_deterministiclg();
+  const std::string& deterministiclg() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_deterministiclg(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_deterministiclg();
+  PROTOBUF_NODISCARD std::string* release_deterministiclg();
+  void set_allocated_deterministiclg(std::string* deterministiclg);
+  private:
+  const std::string& _internal_deterministiclg() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclg(const std::string& value);
+  std::string* _internal_mutable_deterministiclg();
+  public:
+
+  // optional string deterministicLc = 8;
+  bool has_deterministiclc() const;
+  private:
+  bool _internal_has_deterministiclc() const;
+  public:
+  void clear_deterministiclc();
+  const std::string& deterministiclc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_deterministiclc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_deterministiclc();
+  PROTOBUF_NODISCARD std::string* release_deterministiclc();
+  void set_allocated_deterministiclc(std::string* deterministiclc);
+  private:
+  const std::string& _internal_deterministiclc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclc(const std::string& value);
+  std::string* _internal_mutable_deterministiclc();
+  public:
+
+  // optional .proto.Message.TemplateMessage hydratedHsm = 9;
+  bool has_hydratedhsm() const;
+  private:
+  bool _internal_has_hydratedhsm() const;
+  public:
+  void clear_hydratedhsm();
+  const ::proto::Message_TemplateMessage& hydratedhsm() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_hydratedhsm();
+  ::proto::Message_TemplateMessage* mutable_hydratedhsm();
+  void set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm);
+  private:
+  const ::proto::Message_TemplateMessage& _internal_hydratedhsm() const;
+  ::proto::Message_TemplateMessage* _internal_mutable_hydratedhsm();
+  public:
+  void unsafe_arena_set_allocated_hydratedhsm(
+      ::proto::Message_TemplateMessage* hydratedhsm);
+  ::proto::Message_TemplateMessage* unsafe_arena_release_hydratedhsm();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> params_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter > localizableparams_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr elementname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklg_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklc_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclg_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclc_;
+    ::proto::Message_TemplateMessage* hydratedhsm_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_HistorySyncNotification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HistorySyncNotification) */ {
+ public:
+  inline Message_HistorySyncNotification() : Message_HistorySyncNotification(nullptr) {}
+  ~Message_HistorySyncNotification() override;
+  explicit PROTOBUF_CONSTEXPR Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_HistorySyncNotification(const Message_HistorySyncNotification& from);
+  Message_HistorySyncNotification(Message_HistorySyncNotification&& from) noexcept
+    : Message_HistorySyncNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_HistorySyncNotification& operator=(const Message_HistorySyncNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_HistorySyncNotification& operator=(Message_HistorySyncNotification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_HistorySyncNotification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_HistorySyncNotification* internal_default_instance() {
+    return reinterpret_cast<const Message_HistorySyncNotification*>(
+               &_Message_HistorySyncNotification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    83;
+
+  friend void swap(Message_HistorySyncNotification& a, Message_HistorySyncNotification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_HistorySyncNotification* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_HistorySyncNotification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_HistorySyncNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_HistorySyncNotification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_HistorySyncNotification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_HistorySyncNotification& from) {
+    Message_HistorySyncNotification::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_HistorySyncNotification* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.HistorySyncNotification";
+  }
+  protected:
+  explicit Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_HistorySyncNotification_HistorySyncType HistorySyncType;
+  static constexpr HistorySyncType INITIAL_BOOTSTRAP =
+    Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP;
+  static constexpr HistorySyncType INITIAL_STATUS_V3 =
+    Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3;
+  static constexpr HistorySyncType FULL =
+    Message_HistorySyncNotification_HistorySyncType_FULL;
+  static constexpr HistorySyncType RECENT =
+    Message_HistorySyncNotification_HistorySyncType_RECENT;
+  static constexpr HistorySyncType PUSH_NAME =
+    Message_HistorySyncNotification_HistorySyncType_PUSH_NAME;
+  static inline bool HistorySyncType_IsValid(int value) {
+    return Message_HistorySyncNotification_HistorySyncType_IsValid(value);
+  }
+  static constexpr HistorySyncType HistorySyncType_MIN =
+    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN;
+  static constexpr HistorySyncType HistorySyncType_MAX =
+    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX;
+  static constexpr int HistorySyncType_ARRAYSIZE =
+    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HistorySyncType_descriptor() {
+    return Message_HistorySyncNotification_HistorySyncType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HistorySyncType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HistorySyncType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HistorySyncType_Name.");
+    return Message_HistorySyncNotification_HistorySyncType_Name(enum_t_value);
+  }
+  static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HistorySyncType* value) {
+    return Message_HistorySyncNotification_HistorySyncType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileSha256FieldNumber = 1,
+    kMediaKeyFieldNumber = 3,
+    kFileEncSha256FieldNumber = 4,
+    kDirectPathFieldNumber = 5,
+    kOriginalMessageIdFieldNumber = 8,
+    kFileLengthFieldNumber = 2,
+    kSyncTypeFieldNumber = 6,
+    kChunkOrderFieldNumber = 7,
+    kProgressFieldNumber = 9,
+  };
+  // optional bytes fileSha256 = 1;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes mediaKey = 3;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional bytes fileEncSha256 = 4;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 5;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional string originalMessageId = 8;
+  bool has_originalmessageid() const;
+  private:
+  bool _internal_has_originalmessageid() const;
+  public:
+  void clear_originalmessageid();
+  const std::string& originalmessageid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_originalmessageid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_originalmessageid();
+  PROTOBUF_NODISCARD std::string* release_originalmessageid();
+  void set_allocated_originalmessageid(std::string* originalmessageid);
+  private:
+  const std::string& _internal_originalmessageid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalmessageid(const std::string& value);
+  std::string* _internal_mutable_originalmessageid();
+  public:
+
+  // optional uint64 fileLength = 2;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
+  bool has_synctype() const;
+  private:
+  bool _internal_has_synctype() const;
+  public:
+  void clear_synctype();
+  ::proto::Message_HistorySyncNotification_HistorySyncType synctype() const;
+  void set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value);
+  private:
+  ::proto::Message_HistorySyncNotification_HistorySyncType _internal_synctype() const;
+  void _internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value);
+  public:
+
+  // optional uint32 chunkOrder = 7;
+  bool has_chunkorder() const;
+  private:
+  bool _internal_has_chunkorder() const;
+  public:
+  void clear_chunkorder();
+  uint32_t chunkorder() const;
+  void set_chunkorder(uint32_t value);
+  private:
+  uint32_t _internal_chunkorder() const;
+  void _internal_set_chunkorder(uint32_t value);
+  public:
+
+  // optional uint32 progress = 9;
+  bool has_progress() const;
+  private:
+  bool _internal_has_progress() const;
+  public:
+  void clear_progress();
+  uint32_t progress() const;
+  void set_progress(uint32_t value);
+  private:
+  uint32_t _internal_progress() const;
+  void _internal_set_progress(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.HistorySyncNotification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalmessageid_;
+    uint64_t filelength_;
+    int synctype_;
+    uint32_t chunkorder_;
+    uint32_t progress_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ImageMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ImageMessage) */ {
+ public:
+  inline Message_ImageMessage() : Message_ImageMessage(nullptr) {}
+  ~Message_ImageMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ImageMessage(const Message_ImageMessage& from);
+  Message_ImageMessage(Message_ImageMessage&& from) noexcept
+    : Message_ImageMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ImageMessage& operator=(const Message_ImageMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ImageMessage& operator=(Message_ImageMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ImageMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ImageMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ImageMessage*>(
+               &_Message_ImageMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    84;
+
+  friend void swap(Message_ImageMessage& a, Message_ImageMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ImageMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ImageMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ImageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ImageMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ImageMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ImageMessage& from) {
+    Message_ImageMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ImageMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ImageMessage";
+  }
+  protected:
+  explicit Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInteractiveAnnotationsFieldNumber = 10,
+    kScanLengthsFieldNumber = 22,
+    kUrlFieldNumber = 1,
+    kMimetypeFieldNumber = 2,
+    kCaptionFieldNumber = 3,
+    kFileSha256FieldNumber = 4,
+    kMediaKeyFieldNumber = 8,
+    kFileEncSha256FieldNumber = 9,
+    kDirectPathFieldNumber = 11,
+    kJpegThumbnailFieldNumber = 16,
+    kFirstScanSidecarFieldNumber = 18,
+    kScansSidecarFieldNumber = 21,
+    kMidQualityFileSha256FieldNumber = 23,
+    kMidQualityFileEncSha256FieldNumber = 24,
+    kThumbnailDirectPathFieldNumber = 26,
+    kThumbnailSha256FieldNumber = 27,
+    kThumbnailEncSha256FieldNumber = 28,
+    kStaticUrlFieldNumber = 29,
+    kContextInfoFieldNumber = 17,
+    kFileLengthFieldNumber = 5,
+    kHeightFieldNumber = 6,
+    kWidthFieldNumber = 7,
+    kMediaKeyTimestampFieldNumber = 12,
+    kFirstScanLengthFieldNumber = 19,
+    kExperimentGroupIdFieldNumber = 20,
+    kViewOnceFieldNumber = 25,
+  };
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
+  int interactiveannotations_size() const;
+  private:
+  int _internal_interactiveannotations_size() const;
+  public:
+  void clear_interactiveannotations();
+  ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
+      mutable_interactiveannotations();
+  private:
+  const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const;
+  ::proto::InteractiveAnnotation* _internal_add_interactiveannotations();
+  public:
+  const ::proto::InteractiveAnnotation& interactiveannotations(int index) const;
+  ::proto::InteractiveAnnotation* add_interactiveannotations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
+      interactiveannotations() const;
+
+  // repeated uint32 scanLengths = 22;
+  int scanlengths_size() const;
+  private:
+  int _internal_scanlengths_size() const;
+  public:
+  void clear_scanlengths();
+  private:
+  uint32_t _internal_scanlengths(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_scanlengths() const;
+  void _internal_add_scanlengths(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_scanlengths();
+  public:
+  uint32_t scanlengths(int index) const;
+  void set_scanlengths(int index, uint32_t value);
+  void add_scanlengths(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      scanlengths() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_scanlengths();
+
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string mimetype = 2;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional string caption = 3;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional bytes fileSha256 = 4;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes mediaKey = 8;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional bytes fileEncSha256 = 9;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 11;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional bytes firstScanSidecar = 18;
+  bool has_firstscansidecar() const;
+  private:
+  bool _internal_has_firstscansidecar() const;
+  public:
+  void clear_firstscansidecar();
+  const std::string& firstscansidecar() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_firstscansidecar(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_firstscansidecar();
+  PROTOBUF_NODISCARD std::string* release_firstscansidecar();
+  void set_allocated_firstscansidecar(std::string* firstscansidecar);
+  private:
+  const std::string& _internal_firstscansidecar() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstscansidecar(const std::string& value);
+  std::string* _internal_mutable_firstscansidecar();
+  public:
+
+  // optional bytes scansSidecar = 21;
+  bool has_scanssidecar() const;
+  private:
+  bool _internal_has_scanssidecar() const;
+  public:
+  void clear_scanssidecar();
+  const std::string& scanssidecar() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_scanssidecar(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_scanssidecar();
+  PROTOBUF_NODISCARD std::string* release_scanssidecar();
+  void set_allocated_scanssidecar(std::string* scanssidecar);
+  private:
+  const std::string& _internal_scanssidecar() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_scanssidecar(const std::string& value);
+  std::string* _internal_mutable_scanssidecar();
+  public:
+
+  // optional bytes midQualityFileSha256 = 23;
+  bool has_midqualityfilesha256() const;
+  private:
+  bool _internal_has_midqualityfilesha256() const;
+  public:
+  void clear_midqualityfilesha256();
+  const std::string& midqualityfilesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_midqualityfilesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_midqualityfilesha256();
+  PROTOBUF_NODISCARD std::string* release_midqualityfilesha256();
+  void set_allocated_midqualityfilesha256(std::string* midqualityfilesha256);
+  private:
+  const std::string& _internal_midqualityfilesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfilesha256(const std::string& value);
+  std::string* _internal_mutable_midqualityfilesha256();
+  public:
+
+  // optional bytes midQualityFileEncSha256 = 24;
+  bool has_midqualityfileencsha256() const;
+  private:
+  bool _internal_has_midqualityfileencsha256() const;
+  public:
+  void clear_midqualityfileencsha256();
+  const std::string& midqualityfileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_midqualityfileencsha256();
+  PROTOBUF_NODISCARD std::string* release_midqualityfileencsha256();
+  void set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256);
+  private:
+  const std::string& _internal_midqualityfileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfileencsha256(const std::string& value);
+  std::string* _internal_mutable_midqualityfileencsha256();
+  public:
+
+  // optional string thumbnailDirectPath = 26;
+  bool has_thumbnaildirectpath() const;
+  private:
+  bool _internal_has_thumbnaildirectpath() const;
+  public:
+  void clear_thumbnaildirectpath();
+  const std::string& thumbnaildirectpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnaildirectpath();
+  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
+  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
+  private:
+  const std::string& _internal_thumbnaildirectpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
+  std::string* _internal_mutable_thumbnaildirectpath();
+  public:
+
+  // optional bytes thumbnailSha256 = 27;
+  bool has_thumbnailsha256() const;
+  private:
+  bool _internal_has_thumbnailsha256() const;
+  public:
+  void clear_thumbnailsha256();
+  const std::string& thumbnailsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
+  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
+  private:
+  const std::string& _internal_thumbnailsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailsha256();
+  public:
+
+  // optional bytes thumbnailEncSha256 = 28;
+  bool has_thumbnailencsha256() const;
+  private:
+  bool _internal_has_thumbnailencsha256() const;
+  public:
+  void clear_thumbnailencsha256();
+  const std::string& thumbnailencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailencsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
+  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
+  private:
+  const std::string& _internal_thumbnailencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailencsha256();
+  public:
+
+  // optional string staticUrl = 29;
+  bool has_staticurl() const;
+  private:
+  bool _internal_has_staticurl() const;
+  public:
+  void clear_staticurl();
+  const std::string& staticurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_staticurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_staticurl();
+  PROTOBUF_NODISCARD std::string* release_staticurl();
+  void set_allocated_staticurl(std::string* staticurl);
+  private:
+  const std::string& _internal_staticurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value);
+  std::string* _internal_mutable_staticurl();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint64 fileLength = 5;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional uint32 height = 6;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional uint32 width = 7;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 12;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // optional uint32 firstScanLength = 19;
+  bool has_firstscanlength() const;
+  private:
+  bool _internal_has_firstscanlength() const;
+  public:
+  void clear_firstscanlength();
+  uint32_t firstscanlength() const;
+  void set_firstscanlength(uint32_t value);
+  private:
+  uint32_t _internal_firstscanlength() const;
+  void _internal_set_firstscanlength(uint32_t value);
+  public:
+
+  // optional uint32 experimentGroupId = 20;
+  bool has_experimentgroupid() const;
+  private:
+  bool _internal_has_experimentgroupid() const;
+  public:
+  void clear_experimentgroupid();
+  uint32_t experimentgroupid() const;
+  void set_experimentgroupid(uint32_t value);
+  private:
+  uint32_t _internal_experimentgroupid() const;
+  void _internal_set_experimentgroupid(uint32_t value);
+  public:
+
+  // optional bool viewOnce = 25;
+  bool has_viewonce() const;
+  private:
+  bool _internal_has_viewonce() const;
+  public:
+  void clear_viewonce();
+  bool viewonce() const;
+  void set_viewonce(bool value);
+  private:
+  bool _internal_viewonce() const;
+  void _internal_set_viewonce(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ImageMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > scanlengths_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstscansidecar_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scanssidecar_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfilesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_;
+    ::proto::ContextInfo* contextinfo_;
+    uint64_t filelength_;
+    uint32_t height_;
+    uint32_t width_;
+    int64_t mediakeytimestamp_;
+    uint32_t firstscanlength_;
+    uint32_t experimentgroupid_;
+    bool viewonce_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InitialSecurityNotificationSettingSync final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InitialSecurityNotificationSettingSync) */ {
+ public:
+  inline Message_InitialSecurityNotificationSettingSync() : Message_InitialSecurityNotificationSettingSync(nullptr) {}
+  ~Message_InitialSecurityNotificationSettingSync() override;
+  explicit PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from);
+  Message_InitialSecurityNotificationSettingSync(Message_InitialSecurityNotificationSettingSync&& from) noexcept
+    : Message_InitialSecurityNotificationSettingSync() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InitialSecurityNotificationSettingSync& operator=(const Message_InitialSecurityNotificationSettingSync& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InitialSecurityNotificationSettingSync& operator=(Message_InitialSecurityNotificationSettingSync&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InitialSecurityNotificationSettingSync& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InitialSecurityNotificationSettingSync* internal_default_instance() {
+    return reinterpret_cast<const Message_InitialSecurityNotificationSettingSync*>(
+               &_Message_InitialSecurityNotificationSettingSync_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    85;
+
+  friend void swap(Message_InitialSecurityNotificationSettingSync& a, Message_InitialSecurityNotificationSettingSync& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InitialSecurityNotificationSettingSync* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InitialSecurityNotificationSettingSync* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InitialSecurityNotificationSettingSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InitialSecurityNotificationSettingSync>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InitialSecurityNotificationSettingSync& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InitialSecurityNotificationSettingSync& from) {
+    Message_InitialSecurityNotificationSettingSync::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InitialSecurityNotificationSettingSync* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InitialSecurityNotificationSettingSync";
+  }
+  protected:
+  explicit Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSecurityNotificationEnabledFieldNumber = 1,
+  };
+  // optional bool securityNotificationEnabled = 1;
+  bool has_securitynotificationenabled() const;
+  private:
+  bool _internal_has_securitynotificationenabled() const;
+  public:
+  void clear_securitynotificationenabled();
+  bool securitynotificationenabled() const;
+  void set_securitynotificationenabled(bool value);
+  private:
+  bool _internal_securitynotificationenabled() const;
+  void _internal_set_securitynotificationenabled(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InitialSecurityNotificationSettingSync)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool securitynotificationenabled_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_Body final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Body) */ {
+ public:
+  inline Message_InteractiveMessage_Body() : Message_InteractiveMessage_Body(nullptr) {}
+  ~Message_InteractiveMessage_Body() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from);
+  Message_InteractiveMessage_Body(Message_InteractiveMessage_Body&& from) noexcept
+    : Message_InteractiveMessage_Body() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_Body& operator=(const Message_InteractiveMessage_Body& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_Body& operator=(Message_InteractiveMessage_Body&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_Body& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_Body* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_Body*>(
+               &_Message_InteractiveMessage_Body_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    86;
+
+  friend void swap(Message_InteractiveMessage_Body& a, Message_InteractiveMessage_Body& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_Body* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_Body* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_Body>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_Body& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_Body& from) {
+    Message_InteractiveMessage_Body::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_Body* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.Body";
+  }
+  protected:
+  explicit Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 1,
+  };
+  // optional string text = 1;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Body)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_CollectionMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.CollectionMessage) */ {
+ public:
+  inline Message_InteractiveMessage_CollectionMessage() : Message_InteractiveMessage_CollectionMessage(nullptr) {}
+  ~Message_InteractiveMessage_CollectionMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from);
+  Message_InteractiveMessage_CollectionMessage(Message_InteractiveMessage_CollectionMessage&& from) noexcept
+    : Message_InteractiveMessage_CollectionMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_CollectionMessage& operator=(const Message_InteractiveMessage_CollectionMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_CollectionMessage& operator=(Message_InteractiveMessage_CollectionMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_CollectionMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_CollectionMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_CollectionMessage*>(
+               &_Message_InteractiveMessage_CollectionMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    87;
+
+  friend void swap(Message_InteractiveMessage_CollectionMessage& a, Message_InteractiveMessage_CollectionMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_CollectionMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_CollectionMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_CollectionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_CollectionMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_CollectionMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_CollectionMessage& from) {
+    Message_InteractiveMessage_CollectionMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_CollectionMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.CollectionMessage";
+  }
+  protected:
+  explicit Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBizJidFieldNumber = 1,
+    kIdFieldNumber = 2,
+    kMessageVersionFieldNumber = 3,
+  };
+  // optional string bizJid = 1;
+  bool has_bizjid() const;
+  private:
+  bool _internal_has_bizjid() const;
+  public:
+  void clear_bizjid();
+  const std::string& bizjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bizjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bizjid();
+  PROTOBUF_NODISCARD std::string* release_bizjid();
+  void set_allocated_bizjid(std::string* bizjid);
+  private:
+  const std::string& _internal_bizjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizjid(const std::string& value);
+  std::string* _internal_mutable_bizjid();
+  public:
+
+  // optional string id = 2;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional int32 messageVersion = 3;
+  bool has_messageversion() const;
+  private:
+  bool _internal_has_messageversion() const;
+  public:
+  void clear_messageversion();
+  int32_t messageversion() const;
+  void set_messageversion(int32_t value);
+  private:
+  int32_t _internal_messageversion() const;
+  void _internal_set_messageversion(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.CollectionMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    int32_t messageversion_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_Footer final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Footer) */ {
+ public:
+  inline Message_InteractiveMessage_Footer() : Message_InteractiveMessage_Footer(nullptr) {}
+  ~Message_InteractiveMessage_Footer() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from);
+  Message_InteractiveMessage_Footer(Message_InteractiveMessage_Footer&& from) noexcept
+    : Message_InteractiveMessage_Footer() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_Footer& operator=(const Message_InteractiveMessage_Footer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_Footer& operator=(Message_InteractiveMessage_Footer&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_Footer& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_Footer* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_Footer*>(
+               &_Message_InteractiveMessage_Footer_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    88;
+
+  friend void swap(Message_InteractiveMessage_Footer& a, Message_InteractiveMessage_Footer& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_Footer* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_Footer* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_Footer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_Footer>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_Footer& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_Footer& from) {
+    Message_InteractiveMessage_Footer::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_Footer* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.Footer";
+  }
+  protected:
+  explicit Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 1,
+  };
+  // optional string text = 1;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Footer)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_Header final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Header) */ {
+ public:
+  inline Message_InteractiveMessage_Header() : Message_InteractiveMessage_Header(nullptr) {}
+  ~Message_InteractiveMessage_Header() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from);
+  Message_InteractiveMessage_Header(Message_InteractiveMessage_Header&& from) noexcept
+    : Message_InteractiveMessage_Header() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_Header& operator=(const Message_InteractiveMessage_Header& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_Header& operator=(Message_InteractiveMessage_Header&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_Header& default_instance() {
+    return *internal_default_instance();
+  }
+  enum MediaCase {
+    kDocumentMessage = 3,
+    kImageMessage = 4,
+    kJpegThumbnail = 6,
+    kVideoMessage = 7,
+    MEDIA_NOT_SET = 0,
+  };
+
+  static inline const Message_InteractiveMessage_Header* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_Header*>(
+               &_Message_InteractiveMessage_Header_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    89;
+
+  friend void swap(Message_InteractiveMessage_Header& a, Message_InteractiveMessage_Header& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_Header* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_Header* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_Header>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_Header& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_Header& from) {
+    Message_InteractiveMessage_Header::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_Header* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.Header";
+  }
+  protected:
+  explicit Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTitleFieldNumber = 1,
+    kSubtitleFieldNumber = 2,
+    kHasMediaAttachmentFieldNumber = 5,
+    kDocumentMessageFieldNumber = 3,
+    kImageMessageFieldNumber = 4,
+    kJpegThumbnailFieldNumber = 6,
+    kVideoMessageFieldNumber = 7,
+  };
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string subtitle = 2;
+  bool has_subtitle() const;
+  private:
+  bool _internal_has_subtitle() const;
+  public:
+  void clear_subtitle();
+  const std::string& subtitle() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_subtitle(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_subtitle();
+  PROTOBUF_NODISCARD std::string* release_subtitle();
+  void set_allocated_subtitle(std::string* subtitle);
+  private:
+  const std::string& _internal_subtitle() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subtitle(const std::string& value);
+  std::string* _internal_mutable_subtitle();
+  public:
+
+  // optional bool hasMediaAttachment = 5;
+  bool has_hasmediaattachment() const;
+  private:
+  bool _internal_has_hasmediaattachment() const;
+  public:
+  void clear_hasmediaattachment();
+  bool hasmediaattachment() const;
+  void set_hasmediaattachment(bool value);
+  private:
+  bool _internal_hasmediaattachment() const;
+  void _internal_set_hasmediaattachment(bool value);
+  public:
+
+  // .proto.Message.DocumentMessage documentMessage = 3;
+  bool has_documentmessage() const;
+  private:
+  bool _internal_has_documentmessage() const;
+  public:
+  void clear_documentmessage();
+  const ::proto::Message_DocumentMessage& documentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
+  ::proto::Message_DocumentMessage* mutable_documentmessage();
+  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
+  private:
+  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
+  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
+  public:
+  void unsafe_arena_set_allocated_documentmessage(
+      ::proto::Message_DocumentMessage* documentmessage);
+  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();
+
+  // .proto.Message.ImageMessage imageMessage = 4;
+  bool has_imagemessage() const;
+  private:
+  bool _internal_has_imagemessage() const;
+  public:
+  void clear_imagemessage();
+  const ::proto::Message_ImageMessage& imagemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
+  ::proto::Message_ImageMessage* mutable_imagemessage();
+  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
+  public:
+  void unsafe_arena_set_allocated_imagemessage(
+      ::proto::Message_ImageMessage* imagemessage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();
+
+  // bytes jpegThumbnail = 6;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // .proto.Message.VideoMessage videoMessage = 7;
+  bool has_videomessage() const;
+  private:
+  bool _internal_has_videomessage() const;
+  public:
+  void clear_videomessage();
+  const ::proto::Message_VideoMessage& videomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
+  ::proto::Message_VideoMessage* mutable_videomessage();
+  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
+  private:
+  const ::proto::Message_VideoMessage& _internal_videomessage() const;
+  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
+  public:
+  void unsafe_arena_set_allocated_videomessage(
+      ::proto::Message_VideoMessage* videomessage);
+  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();
+
+  void clear_media();
+  MediaCase media_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Header)
+ private:
+  class _Internal;
+  void set_has_documentmessage();
+  void set_has_imagemessage();
+  void set_has_jpegthumbnail();
+  void set_has_videomessage();
+
+  inline bool has_media() const;
+  inline void clear_has_media();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtitle_;
+    bool hasmediaattachment_;
+    union MediaUnion {
+      constexpr MediaUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_DocumentMessage* documentmessage_;
+      ::proto::Message_ImageMessage* imagemessage_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+      ::proto::Message_VideoMessage* videomessage_;
+    } media_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) */ {
+ public:
+  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(nullptr) {}
+  ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from);
+  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept
+    : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton*>(
+               &_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    90;
+
+  friend void swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& a, Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) {
+    Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton";
+  }
+  protected:
+  explicit Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kButtonParamsJsonFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string buttonParamsJson = 2;
+  bool has_buttonparamsjson() const;
+  private:
+  bool _internal_has_buttonparamsjson() const;
+  public:
+  void clear_buttonparamsjson();
+  const std::string& buttonparamsjson() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_buttonparamsjson(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_buttonparamsjson();
+  PROTOBUF_NODISCARD std::string* release_buttonparamsjson();
+  void set_allocated_buttonparamsjson(std::string* buttonparamsjson);
+  private:
+  const std::string& _internal_buttonparamsjson() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonparamsjson(const std::string& value);
+  std::string* _internal_mutable_buttonparamsjson();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonparamsjson_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_NativeFlowMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage) */ {
+ public:
+  inline Message_InteractiveMessage_NativeFlowMessage() : Message_InteractiveMessage_NativeFlowMessage(nullptr) {}
+  ~Message_InteractiveMessage_NativeFlowMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from);
+  Message_InteractiveMessage_NativeFlowMessage(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept
+    : Message_InteractiveMessage_NativeFlowMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_NativeFlowMessage& operator=(const Message_InteractiveMessage_NativeFlowMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_NativeFlowMessage& operator=(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_NativeFlowMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_NativeFlowMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_NativeFlowMessage*>(
+               &_Message_InteractiveMessage_NativeFlowMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    91;
+
+  friend void swap(Message_InteractiveMessage_NativeFlowMessage& a, Message_InteractiveMessage_NativeFlowMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_NativeFlowMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_NativeFlowMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_NativeFlowMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage& from) {
+    Message_InteractiveMessage_NativeFlowMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.NativeFlowMessage";
+  }
+  protected:
+  explicit Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton NativeFlowButton;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kButtonsFieldNumber = 1,
+    kMessageParamsJsonFieldNumber = 2,
+    kMessageVersionFieldNumber = 3,
+  };
+  // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
+  int buttons_size() const;
+  private:
+  int _internal_buttons_size() const;
+  public:
+  void clear_buttons();
+  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* mutable_buttons(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >*
+      mutable_buttons();
+  private:
+  const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& _internal_buttons(int index) const;
+  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _internal_add_buttons();
+  public:
+  const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& buttons(int index) const;
+  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* add_buttons();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >&
+      buttons() const;
+
+  // optional string messageParamsJson = 2;
+  bool has_messageparamsjson() const;
+  private:
+  bool _internal_has_messageparamsjson() const;
+  public:
+  void clear_messageparamsjson();
+  const std::string& messageparamsjson() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_messageparamsjson(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_messageparamsjson();
+  PROTOBUF_NODISCARD std::string* release_messageparamsjson();
+  void set_allocated_messageparamsjson(std::string* messageparamsjson);
+  private:
+  const std::string& _internal_messageparamsjson() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageparamsjson(const std::string& value);
+  std::string* _internal_mutable_messageparamsjson();
+  public:
+
+  // optional int32 messageVersion = 3;
+  bool has_messageversion() const;
+  private:
+  bool _internal_has_messageversion() const;
+  public:
+  void clear_messageversion();
+  int32_t messageversion() const;
+  void set_messageversion(int32_t value);
+  private:
+  int32_t _internal_messageversion() const;
+  void _internal_set_messageversion(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton > buttons_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageparamsjson_;
+    int32_t messageversion_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage_ShopMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.ShopMessage) */ {
+ public:
+  inline Message_InteractiveMessage_ShopMessage() : Message_InteractiveMessage_ShopMessage(nullptr) {}
+  ~Message_InteractiveMessage_ShopMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from);
+  Message_InteractiveMessage_ShopMessage(Message_InteractiveMessage_ShopMessage&& from) noexcept
+    : Message_InteractiveMessage_ShopMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage_ShopMessage& operator=(const Message_InteractiveMessage_ShopMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage_ShopMessage& operator=(Message_InteractiveMessage_ShopMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage_ShopMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveMessage_ShopMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage_ShopMessage*>(
+               &_Message_InteractiveMessage_ShopMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    92;
+
+  friend void swap(Message_InteractiveMessage_ShopMessage& a, Message_InteractiveMessage_ShopMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage_ShopMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage_ShopMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage_ShopMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage_ShopMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage_ShopMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage_ShopMessage& from) {
+    Message_InteractiveMessage_ShopMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage_ShopMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage.ShopMessage";
+  }
+  protected:
+  explicit Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_InteractiveMessage_ShopMessage_Surface Surface;
+  static constexpr Surface UNKNOWN_SURFACE =
+    Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE;
+  static constexpr Surface FB =
+    Message_InteractiveMessage_ShopMessage_Surface_FB;
+  static constexpr Surface IG =
+    Message_InteractiveMessage_ShopMessage_Surface_IG;
+  static constexpr Surface WA =
+    Message_InteractiveMessage_ShopMessage_Surface_WA;
+  static inline bool Surface_IsValid(int value) {
+    return Message_InteractiveMessage_ShopMessage_Surface_IsValid(value);
+  }
+  static constexpr Surface Surface_MIN =
+    Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN;
+  static constexpr Surface Surface_MAX =
+    Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX;
+  static constexpr int Surface_ARRAYSIZE =
+    Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Surface_descriptor() {
+    return Message_InteractiveMessage_ShopMessage_Surface_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Surface_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Surface>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Surface_Name.");
+    return Message_InteractiveMessage_ShopMessage_Surface_Name(enum_t_value);
+  }
+  static inline bool Surface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Surface* value) {
+    return Message_InteractiveMessage_ShopMessage_Surface_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kSurfaceFieldNumber = 2,
+    kMessageVersionFieldNumber = 3,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
+  bool has_surface() const;
+  private:
+  bool _internal_has_surface() const;
+  public:
+  void clear_surface();
+  ::proto::Message_InteractiveMessage_ShopMessage_Surface surface() const;
+  void set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value);
+  private:
+  ::proto::Message_InteractiveMessage_ShopMessage_Surface _internal_surface() const;
+  void _internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value);
+  public:
+
+  // optional int32 messageVersion = 3;
+  bool has_messageversion() const;
+  private:
+  bool _internal_has_messageversion() const;
+  public:
+  void clear_messageversion();
+  int32_t messageversion() const;
+  void set_messageversion(int32_t value);
+  private:
+  int32_t _internal_messageversion() const;
+  void _internal_set_messageversion(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.ShopMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    int surface_;
+    int32_t messageversion_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage) */ {
+ public:
+  inline Message_InteractiveMessage() : Message_InteractiveMessage(nullptr) {}
+  ~Message_InteractiveMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveMessage(const Message_InteractiveMessage& from);
+  Message_InteractiveMessage(Message_InteractiveMessage&& from) noexcept
+    : Message_InteractiveMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveMessage& operator=(const Message_InteractiveMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveMessage& operator=(Message_InteractiveMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  enum InteractiveMessageCase {
+    kShopStorefrontMessage = 4,
+    kCollectionMessage = 5,
+    kNativeFlowMessage = 6,
+    INTERACTIVEMESSAGE_NOT_SET = 0,
+  };
+
+  static inline const Message_InteractiveMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveMessage*>(
+               &_Message_InteractiveMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    93;
+
+  friend void swap(Message_InteractiveMessage& a, Message_InteractiveMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveMessage& from) {
+    Message_InteractiveMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveMessage";
+  }
+  protected:
+  explicit Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_InteractiveMessage_Body Body;
+  typedef Message_InteractiveMessage_CollectionMessage CollectionMessage;
+  typedef Message_InteractiveMessage_Footer Footer;
+  typedef Message_InteractiveMessage_Header Header;
+  typedef Message_InteractiveMessage_NativeFlowMessage NativeFlowMessage;
+  typedef Message_InteractiveMessage_ShopMessage ShopMessage;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeaderFieldNumber = 1,
+    kBodyFieldNumber = 2,
+    kFooterFieldNumber = 3,
+    kContextInfoFieldNumber = 15,
+    kShopStorefrontMessageFieldNumber = 4,
+    kCollectionMessageFieldNumber = 5,
+    kNativeFlowMessageFieldNumber = 6,
+  };
+  // optional .proto.Message.InteractiveMessage.Header header = 1;
+  bool has_header() const;
+  private:
+  bool _internal_has_header() const;
+  public:
+  void clear_header();
+  const ::proto::Message_InteractiveMessage_Header& header() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Header* release_header();
+  ::proto::Message_InteractiveMessage_Header* mutable_header();
+  void set_allocated_header(::proto::Message_InteractiveMessage_Header* header);
+  private:
+  const ::proto::Message_InteractiveMessage_Header& _internal_header() const;
+  ::proto::Message_InteractiveMessage_Header* _internal_mutable_header();
+  public:
+  void unsafe_arena_set_allocated_header(
+      ::proto::Message_InteractiveMessage_Header* header);
+  ::proto::Message_InteractiveMessage_Header* unsafe_arena_release_header();
+
+  // optional .proto.Message.InteractiveMessage.Body body = 2;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const ::proto::Message_InteractiveMessage_Body& body() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Body* release_body();
+  ::proto::Message_InteractiveMessage_Body* mutable_body();
+  void set_allocated_body(::proto::Message_InteractiveMessage_Body* body);
+  private:
+  const ::proto::Message_InteractiveMessage_Body& _internal_body() const;
+  ::proto::Message_InteractiveMessage_Body* _internal_mutable_body();
+  public:
+  void unsafe_arena_set_allocated_body(
+      ::proto::Message_InteractiveMessage_Body* body);
+  ::proto::Message_InteractiveMessage_Body* unsafe_arena_release_body();
+
+  // optional .proto.Message.InteractiveMessage.Footer footer = 3;
+  bool has_footer() const;
+  private:
+  bool _internal_has_footer() const;
+  public:
+  void clear_footer();
+  const ::proto::Message_InteractiveMessage_Footer& footer() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Footer* release_footer();
+  ::proto::Message_InteractiveMessage_Footer* mutable_footer();
+  void set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer);
+  private:
+  const ::proto::Message_InteractiveMessage_Footer& _internal_footer() const;
+  ::proto::Message_InteractiveMessage_Footer* _internal_mutable_footer();
+  public:
+  void unsafe_arena_set_allocated_footer(
+      ::proto::Message_InteractiveMessage_Footer* footer);
+  ::proto::Message_InteractiveMessage_Footer* unsafe_arena_release_footer();
+
+  // optional .proto.ContextInfo contextInfo = 15;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
+  bool has_shopstorefrontmessage() const;
+  private:
+  bool _internal_has_shopstorefrontmessage() const;
+  public:
+  void clear_shopstorefrontmessage();
+  const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_ShopMessage* release_shopstorefrontmessage();
+  ::proto::Message_InteractiveMessage_ShopMessage* mutable_shopstorefrontmessage();
+  void set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage);
+  private:
+  const ::proto::Message_InteractiveMessage_ShopMessage& _internal_shopstorefrontmessage() const;
+  ::proto::Message_InteractiveMessage_ShopMessage* _internal_mutable_shopstorefrontmessage();
+  public:
+  void unsafe_arena_set_allocated_shopstorefrontmessage(
+      ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage);
+  ::proto::Message_InteractiveMessage_ShopMessage* unsafe_arena_release_shopstorefrontmessage();
+
+  // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
+  bool has_collectionmessage() const;
+  private:
+  bool _internal_has_collectionmessage() const;
+  public:
+  void clear_collectionmessage();
+  const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_CollectionMessage* release_collectionmessage();
+  ::proto::Message_InteractiveMessage_CollectionMessage* mutable_collectionmessage();
+  void set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage);
+  private:
+  const ::proto::Message_InteractiveMessage_CollectionMessage& _internal_collectionmessage() const;
+  ::proto::Message_InteractiveMessage_CollectionMessage* _internal_mutable_collectionmessage();
+  public:
+  void unsafe_arena_set_allocated_collectionmessage(
+      ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage);
+  ::proto::Message_InteractiveMessage_CollectionMessage* unsafe_arena_release_collectionmessage();
+
+  // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
+  bool has_nativeflowmessage() const;
+  private:
+  bool _internal_has_nativeflowmessage() const;
+  public:
+  void clear_nativeflowmessage();
+  const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_NativeFlowMessage* release_nativeflowmessage();
+  ::proto::Message_InteractiveMessage_NativeFlowMessage* mutable_nativeflowmessage();
+  void set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage);
+  private:
+  const ::proto::Message_InteractiveMessage_NativeFlowMessage& _internal_nativeflowmessage() const;
+  ::proto::Message_InteractiveMessage_NativeFlowMessage* _internal_mutable_nativeflowmessage();
+  public:
+  void unsafe_arena_set_allocated_nativeflowmessage(
+      ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage);
+  ::proto::Message_InteractiveMessage_NativeFlowMessage* unsafe_arena_release_nativeflowmessage();
+
+  void clear_interactiveMessage();
+  InteractiveMessageCase interactiveMessage_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage)
+ private:
+  class _Internal;
+  void set_has_shopstorefrontmessage();
+  void set_has_collectionmessage();
+  void set_has_nativeflowmessage();
+
+  inline bool has_interactiveMessage() const;
+  inline void clear_has_interactiveMessage();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message_InteractiveMessage_Header* header_;
+    ::proto::Message_InteractiveMessage_Body* body_;
+    ::proto::Message_InteractiveMessage_Footer* footer_;
+    ::proto::ContextInfo* contextinfo_;
+    union InteractiveMessageUnion {
+      constexpr InteractiveMessageUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage_;
+      ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage_;
+      ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage_;
+    } interactiveMessage_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveResponseMessage_Body final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.Body) */ {
+ public:
+  inline Message_InteractiveResponseMessage_Body() : Message_InteractiveResponseMessage_Body(nullptr) {}
+  ~Message_InteractiveResponseMessage_Body() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from);
+  Message_InteractiveResponseMessage_Body(Message_InteractiveResponseMessage_Body&& from) noexcept
+    : Message_InteractiveResponseMessage_Body() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveResponseMessage_Body& operator=(const Message_InteractiveResponseMessage_Body& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveResponseMessage_Body& operator=(Message_InteractiveResponseMessage_Body&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveResponseMessage_Body& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveResponseMessage_Body* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveResponseMessage_Body*>(
+               &_Message_InteractiveResponseMessage_Body_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    94;
+
+  friend void swap(Message_InteractiveResponseMessage_Body& a, Message_InteractiveResponseMessage_Body& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveResponseMessage_Body* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveResponseMessage_Body* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveResponseMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveResponseMessage_Body>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveResponseMessage_Body& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveResponseMessage_Body& from) {
+    Message_InteractiveResponseMessage_Body::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveResponseMessage_Body* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveResponseMessage.Body";
+  }
+  protected:
+  explicit Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 1,
+  };
+  // optional string text = 1;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.Body)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveResponseMessage_NativeFlowResponseMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) */ {
+ public:
+  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage() : Message_InteractiveResponseMessage_NativeFlowResponseMessage(nullptr) {}
+  ~Message_InteractiveResponseMessage_NativeFlowResponseMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from);
+  Message_InteractiveResponseMessage_NativeFlowResponseMessage(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept
+    : Message_InteractiveResponseMessage_NativeFlowResponseMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveResponseMessage_NativeFlowResponseMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InteractiveResponseMessage_NativeFlowResponseMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveResponseMessage_NativeFlowResponseMessage*>(
+               &_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    95;
+
+  friend void swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage& a, Message_InteractiveResponseMessage_NativeFlowResponseMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveResponseMessage_NativeFlowResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveResponseMessage_NativeFlowResponseMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) {
+    Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage";
+  }
+  protected:
+  explicit Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kParamsJsonFieldNumber = 2,
+    kVersionFieldNumber = 3,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string paramsJson = 2;
+  bool has_paramsjson() const;
+  private:
+  bool _internal_has_paramsjson() const;
+  public:
+  void clear_paramsjson();
+  const std::string& paramsjson() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_paramsjson(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_paramsjson();
+  PROTOBUF_NODISCARD std::string* release_paramsjson();
+  void set_allocated_paramsjson(std::string* paramsjson);
+  private:
+  const std::string& _internal_paramsjson() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value);
+  std::string* _internal_mutable_paramsjson();
+  public:
+
+  // optional int32 version = 3;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  int32_t version() const;
+  void set_version(int32_t value);
+  private:
+  int32_t _internal_version() const;
+  void _internal_set_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_;
+    int32_t version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InteractiveResponseMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage) */ {
+ public:
+  inline Message_InteractiveResponseMessage() : Message_InteractiveResponseMessage(nullptr) {}
+  ~Message_InteractiveResponseMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from);
+  Message_InteractiveResponseMessage(Message_InteractiveResponseMessage&& from) noexcept
+    : Message_InteractiveResponseMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InteractiveResponseMessage& operator=(const Message_InteractiveResponseMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InteractiveResponseMessage& operator=(Message_InteractiveResponseMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InteractiveResponseMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  enum InteractiveResponseMessageCase {
+    kNativeFlowResponseMessage = 2,
+    INTERACTIVERESPONSEMESSAGE_NOT_SET = 0,
+  };
+
+  static inline const Message_InteractiveResponseMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InteractiveResponseMessage*>(
+               &_Message_InteractiveResponseMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    96;
+
+  friend void swap(Message_InteractiveResponseMessage& a, Message_InteractiveResponseMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InteractiveResponseMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InteractiveResponseMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InteractiveResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InteractiveResponseMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InteractiveResponseMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InteractiveResponseMessage& from) {
+    Message_InteractiveResponseMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InteractiveResponseMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InteractiveResponseMessage";
+  }
+  protected:
+  explicit Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_InteractiveResponseMessage_Body Body;
+  typedef Message_InteractiveResponseMessage_NativeFlowResponseMessage NativeFlowResponseMessage;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBodyFieldNumber = 1,
+    kContextInfoFieldNumber = 15,
+    kNativeFlowResponseMessageFieldNumber = 2,
+  };
+  // optional .proto.Message.InteractiveResponseMessage.Body body = 1;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const ::proto::Message_InteractiveResponseMessage_Body& body() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_Body* release_body();
+  ::proto::Message_InteractiveResponseMessage_Body* mutable_body();
+  void set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body);
+  private:
+  const ::proto::Message_InteractiveResponseMessage_Body& _internal_body() const;
+  ::proto::Message_InteractiveResponseMessage_Body* _internal_mutable_body();
+  public:
+  void unsafe_arena_set_allocated_body(
+      ::proto::Message_InteractiveResponseMessage_Body* body);
+  ::proto::Message_InteractiveResponseMessage_Body* unsafe_arena_release_body();
+
+  // optional .proto.ContextInfo contextInfo = 15;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+  bool has_nativeflowresponsemessage() const;
+  private:
+  bool _internal_has_nativeflowresponsemessage() const;
+  public:
+  void clear_nativeflowresponsemessage();
+  const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* release_nativeflowresponsemessage();
+  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* mutable_nativeflowresponsemessage();
+  void set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage);
+  private:
+  const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& _internal_nativeflowresponsemessage() const;
+  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _internal_mutable_nativeflowresponsemessage();
+  public:
+  void unsafe_arena_set_allocated_nativeflowresponsemessage(
+      ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage);
+  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* unsafe_arena_release_nativeflowresponsemessage();
+
+  void clear_interactiveResponseMessage();
+  InteractiveResponseMessageCase interactiveResponseMessage_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage)
+ private:
+  class _Internal;
+  void set_has_nativeflowresponsemessage();
+
+  inline bool has_interactiveResponseMessage() const;
+  inline void clear_has_interactiveResponseMessage();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message_InteractiveResponseMessage_Body* body_;
+    ::proto::ContextInfo* contextinfo_;
+    union InteractiveResponseMessageUnion {
+      constexpr InteractiveResponseMessageUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage_;
+    } interactiveResponseMessage_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_InvoiceMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InvoiceMessage) */ {
+ public:
+  inline Message_InvoiceMessage() : Message_InvoiceMessage(nullptr) {}
+  ~Message_InvoiceMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_InvoiceMessage(const Message_InvoiceMessage& from);
+  Message_InvoiceMessage(Message_InvoiceMessage&& from) noexcept
+    : Message_InvoiceMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_InvoiceMessage& operator=(const Message_InvoiceMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_InvoiceMessage& operator=(Message_InvoiceMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_InvoiceMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_InvoiceMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_InvoiceMessage*>(
+               &_Message_InvoiceMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    97;
+
+  friend void swap(Message_InvoiceMessage& a, Message_InvoiceMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_InvoiceMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_InvoiceMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_InvoiceMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_InvoiceMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_InvoiceMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_InvoiceMessage& from) {
+    Message_InvoiceMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_InvoiceMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.InvoiceMessage";
+  }
+  protected:
+  explicit Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_InvoiceMessage_AttachmentType AttachmentType;
+  static constexpr AttachmentType IMAGE =
+    Message_InvoiceMessage_AttachmentType_IMAGE;
+  static constexpr AttachmentType PDF =
+    Message_InvoiceMessage_AttachmentType_PDF;
+  static inline bool AttachmentType_IsValid(int value) {
+    return Message_InvoiceMessage_AttachmentType_IsValid(value);
+  }
+  static constexpr AttachmentType AttachmentType_MIN =
+    Message_InvoiceMessage_AttachmentType_AttachmentType_MIN;
+  static constexpr AttachmentType AttachmentType_MAX =
+    Message_InvoiceMessage_AttachmentType_AttachmentType_MAX;
+  static constexpr int AttachmentType_ARRAYSIZE =
+    Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  AttachmentType_descriptor() {
+    return Message_InvoiceMessage_AttachmentType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& AttachmentType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, AttachmentType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function AttachmentType_Name.");
+    return Message_InvoiceMessage_AttachmentType_Name(enum_t_value);
+  }
+  static inline bool AttachmentType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      AttachmentType* value) {
+    return Message_InvoiceMessage_AttachmentType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNoteFieldNumber = 1,
+    kTokenFieldNumber = 2,
+    kAttachmentMimetypeFieldNumber = 4,
+    kAttachmentMediaKeyFieldNumber = 5,
+    kAttachmentFileSha256FieldNumber = 7,
+    kAttachmentFileEncSha256FieldNumber = 8,
+    kAttachmentDirectPathFieldNumber = 9,
+    kAttachmentJpegThumbnailFieldNumber = 10,
+    kAttachmentMediaKeyTimestampFieldNumber = 6,
+    kAttachmentTypeFieldNumber = 3,
+  };
+  // optional string note = 1;
+  bool has_note() const;
+  private:
+  bool _internal_has_note() const;
+  public:
+  void clear_note();
+  const std::string& note() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_note(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_note();
+  PROTOBUF_NODISCARD std::string* release_note();
+  void set_allocated_note(std::string* note);
+  private:
+  const std::string& _internal_note() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_note(const std::string& value);
+  std::string* _internal_mutable_note();
+  public:
+
+  // optional string token = 2;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional string attachmentMimetype = 4;
+  bool has_attachmentmimetype() const;
+  private:
+  bool _internal_has_attachmentmimetype() const;
+  public:
+  void clear_attachmentmimetype();
+  const std::string& attachmentmimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentmimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentmimetype();
+  PROTOBUF_NODISCARD std::string* release_attachmentmimetype();
+  void set_allocated_attachmentmimetype(std::string* attachmentmimetype);
+  private:
+  const std::string& _internal_attachmentmimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmimetype(const std::string& value);
+  std::string* _internal_mutable_attachmentmimetype();
+  public:
+
+  // optional bytes attachmentMediaKey = 5;
+  bool has_attachmentmediakey() const;
+  private:
+  bool _internal_has_attachmentmediakey() const;
+  public:
+  void clear_attachmentmediakey();
+  const std::string& attachmentmediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentmediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentmediakey();
+  PROTOBUF_NODISCARD std::string* release_attachmentmediakey();
+  void set_allocated_attachmentmediakey(std::string* attachmentmediakey);
+  private:
+  const std::string& _internal_attachmentmediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmediakey(const std::string& value);
+  std::string* _internal_mutable_attachmentmediakey();
+  public:
+
+  // optional bytes attachmentFileSha256 = 7;
+  bool has_attachmentfilesha256() const;
+  private:
+  bool _internal_has_attachmentfilesha256() const;
+  public:
+  void clear_attachmentfilesha256();
+  const std::string& attachmentfilesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentfilesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentfilesha256();
+  PROTOBUF_NODISCARD std::string* release_attachmentfilesha256();
+  void set_allocated_attachmentfilesha256(std::string* attachmentfilesha256);
+  private:
+  const std::string& _internal_attachmentfilesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfilesha256(const std::string& value);
+  std::string* _internal_mutable_attachmentfilesha256();
+  public:
+
+  // optional bytes attachmentFileEncSha256 = 8;
+  bool has_attachmentfileencsha256() const;
+  private:
+  bool _internal_has_attachmentfileencsha256() const;
+  public:
+  void clear_attachmentfileencsha256();
+  const std::string& attachmentfileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentfileencsha256();
+  PROTOBUF_NODISCARD std::string* release_attachmentfileencsha256();
+  void set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256);
+  private:
+  const std::string& _internal_attachmentfileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfileencsha256(const std::string& value);
+  std::string* _internal_mutable_attachmentfileencsha256();
+  public:
+
+  // optional string attachmentDirectPath = 9;
+  bool has_attachmentdirectpath() const;
+  private:
+  bool _internal_has_attachmentdirectpath() const;
+  public:
+  void clear_attachmentdirectpath();
+  const std::string& attachmentdirectpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentdirectpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentdirectpath();
+  PROTOBUF_NODISCARD std::string* release_attachmentdirectpath();
+  void set_allocated_attachmentdirectpath(std::string* attachmentdirectpath);
+  private:
+  const std::string& _internal_attachmentdirectpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentdirectpath(const std::string& value);
+  std::string* _internal_mutable_attachmentdirectpath();
+  public:
+
+  // optional bytes attachmentJpegThumbnail = 10;
+  bool has_attachmentjpegthumbnail() const;
+  private:
+  bool _internal_has_attachmentjpegthumbnail() const;
+  public:
+  void clear_attachmentjpegthumbnail();
+  const std::string& attachmentjpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_attachmentjpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_attachmentjpegthumbnail();
+  void set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail);
+  private:
+  const std::string& _internal_attachmentjpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentjpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_attachmentjpegthumbnail();
+  public:
+
+  // optional int64 attachmentMediaKeyTimestamp = 6;
+  bool has_attachmentmediakeytimestamp() const;
+  private:
+  bool _internal_has_attachmentmediakeytimestamp() const;
+  public:
+  void clear_attachmentmediakeytimestamp();
+  int64_t attachmentmediakeytimestamp() const;
+  void set_attachmentmediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_attachmentmediakeytimestamp() const;
+  void _internal_set_attachmentmediakeytimestamp(int64_t value);
+  public:
+
+  // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
+  bool has_attachmenttype() const;
+  private:
+  bool _internal_has_attachmenttype() const;
+  public:
+  void clear_attachmenttype();
+  ::proto::Message_InvoiceMessage_AttachmentType attachmenttype() const;
+  void set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value);
+  private:
+  ::proto::Message_InvoiceMessage_AttachmentType _internal_attachmenttype() const;
+  void _internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.InvoiceMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr note_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfilesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentdirectpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentjpegthumbnail_;
+    int64_t attachmentmediakeytimestamp_;
+    int attachmenttype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_KeepInChatMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.KeepInChatMessage) */ {
+ public:
+  inline Message_KeepInChatMessage() : Message_KeepInChatMessage(nullptr) {}
+  ~Message_KeepInChatMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_KeepInChatMessage(const Message_KeepInChatMessage& from);
+  Message_KeepInChatMessage(Message_KeepInChatMessage&& from) noexcept
+    : Message_KeepInChatMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_KeepInChatMessage& operator=(const Message_KeepInChatMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_KeepInChatMessage& operator=(Message_KeepInChatMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_KeepInChatMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_KeepInChatMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_KeepInChatMessage*>(
+               &_Message_KeepInChatMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    98;
+
+  friend void swap(Message_KeepInChatMessage& a, Message_KeepInChatMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_KeepInChatMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_KeepInChatMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_KeepInChatMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_KeepInChatMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_KeepInChatMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_KeepInChatMessage& from) {
+    Message_KeepInChatMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_KeepInChatMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.KeepInChatMessage";
+  }
+  protected:
+  explicit Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kTimestampMsFieldNumber = 3,
+    kKeepTypeFieldNumber = 2,
+  };
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional int64 timestampMs = 3;
+  bool has_timestampms() const;
+  private:
+  bool _internal_has_timestampms() const;
+  public:
+  void clear_timestampms();
+  int64_t timestampms() const;
+  void set_timestampms(int64_t value);
+  private:
+  int64_t _internal_timestampms() const;
+  void _internal_set_timestampms(int64_t value);
+  public:
+
+  // optional .proto.KeepType keepType = 2;
+  bool has_keeptype() const;
+  private:
+  bool _internal_has_keeptype() const;
+  public:
+  void clear_keeptype();
+  ::proto::KeepType keeptype() const;
+  void set_keeptype(::proto::KeepType value);
+  private:
+  ::proto::KeepType _internal_keeptype() const;
+  void _internal_set_keeptype(::proto::KeepType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.KeepInChatMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* key_;
+    int64_t timestampms_;
+    int keeptype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_ProductListHeaderImage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListHeaderImage) */ {
+ public:
+  inline Message_ListMessage_ProductListHeaderImage() : Message_ListMessage_ProductListHeaderImage(nullptr) {}
+  ~Message_ListMessage_ProductListHeaderImage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from);
+  Message_ListMessage_ProductListHeaderImage(Message_ListMessage_ProductListHeaderImage&& from) noexcept
+    : Message_ListMessage_ProductListHeaderImage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_ProductListHeaderImage& operator=(const Message_ListMessage_ProductListHeaderImage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_ProductListHeaderImage& operator=(Message_ListMessage_ProductListHeaderImage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_ProductListHeaderImage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_ProductListHeaderImage* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_ProductListHeaderImage*>(
+               &_Message_ListMessage_ProductListHeaderImage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    99;
+
+  friend void swap(Message_ListMessage_ProductListHeaderImage& a, Message_ListMessage_ProductListHeaderImage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_ProductListHeaderImage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_ProductListHeaderImage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_ProductListHeaderImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_ProductListHeaderImage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_ProductListHeaderImage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_ProductListHeaderImage& from) {
+    Message_ListMessage_ProductListHeaderImage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_ProductListHeaderImage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.ProductListHeaderImage";
+  }
+  protected:
+  explicit Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductIdFieldNumber = 1,
+    kJpegThumbnailFieldNumber = 2,
+  };
+  // optional string productId = 1;
+  bool has_productid() const;
+  private:
+  bool _internal_has_productid() const;
+  public:
+  void clear_productid();
+  const std::string& productid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_productid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_productid();
+  PROTOBUF_NODISCARD std::string* release_productid();
+  void set_allocated_productid(std::string* productid);
+  private:
+  const std::string& _internal_productid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
+  std::string* _internal_mutable_productid();
+  public:
+
+  // optional bytes jpegThumbnail = 2;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListHeaderImage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_ProductListInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListInfo) */ {
+ public:
+  inline Message_ListMessage_ProductListInfo() : Message_ListMessage_ProductListInfo(nullptr) {}
+  ~Message_ListMessage_ProductListInfo() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from);
+  Message_ListMessage_ProductListInfo(Message_ListMessage_ProductListInfo&& from) noexcept
+    : Message_ListMessage_ProductListInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_ProductListInfo& operator=(const Message_ListMessage_ProductListInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_ProductListInfo& operator=(Message_ListMessage_ProductListInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_ProductListInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_ProductListInfo* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_ProductListInfo*>(
+               &_Message_ListMessage_ProductListInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    100;
+
+  friend void swap(Message_ListMessage_ProductListInfo& a, Message_ListMessage_ProductListInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_ProductListInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_ProductListInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_ProductListInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_ProductListInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_ProductListInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_ProductListInfo& from) {
+    Message_ListMessage_ProductListInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_ProductListInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.ProductListInfo";
+  }
+  protected:
+  explicit Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductSectionsFieldNumber = 1,
+    kBusinessOwnerJidFieldNumber = 3,
+    kHeaderImageFieldNumber = 2,
+  };
+  // repeated .proto.Message.ListMessage.ProductSection productSections = 1;
+  int productsections_size() const;
+  private:
+  int _internal_productsections_size() const;
+  public:
+  void clear_productsections();
+  ::proto::Message_ListMessage_ProductSection* mutable_productsections(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >*
+      mutable_productsections();
+  private:
+  const ::proto::Message_ListMessage_ProductSection& _internal_productsections(int index) const;
+  ::proto::Message_ListMessage_ProductSection* _internal_add_productsections();
+  public:
+  const ::proto::Message_ListMessage_ProductSection& productsections(int index) const;
+  ::proto::Message_ListMessage_ProductSection* add_productsections();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >&
+      productsections() const;
+
+  // optional string businessOwnerJid = 3;
+  bool has_businessownerjid() const;
+  private:
+  bool _internal_has_businessownerjid() const;
+  public:
+  void clear_businessownerjid();
+  const std::string& businessownerjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_businessownerjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_businessownerjid();
+  PROTOBUF_NODISCARD std::string* release_businessownerjid();
+  void set_allocated_businessownerjid(std::string* businessownerjid);
+  private:
+  const std::string& _internal_businessownerjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value);
+  std::string* _internal_mutable_businessownerjid();
+  public:
+
+  // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
+  bool has_headerimage() const;
+  private:
+  bool _internal_has_headerimage() const;
+  public:
+  void clear_headerimage();
+  const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListHeaderImage* release_headerimage();
+  ::proto::Message_ListMessage_ProductListHeaderImage* mutable_headerimage();
+  void set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage);
+  private:
+  const ::proto::Message_ListMessage_ProductListHeaderImage& _internal_headerimage() const;
+  ::proto::Message_ListMessage_ProductListHeaderImage* _internal_mutable_headerimage();
+  public:
+  void unsafe_arena_set_allocated_headerimage(
+      ::proto::Message_ListMessage_ProductListHeaderImage* headerimage);
+  ::proto::Message_ListMessage_ProductListHeaderImage* unsafe_arena_release_headerimage();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection > productsections_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_;
+    ::proto::Message_ListMessage_ProductListHeaderImage* headerimage_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_ProductSection final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductSection) */ {
+ public:
+  inline Message_ListMessage_ProductSection() : Message_ListMessage_ProductSection(nullptr) {}
+  ~Message_ListMessage_ProductSection() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from);
+  Message_ListMessage_ProductSection(Message_ListMessage_ProductSection&& from) noexcept
+    : Message_ListMessage_ProductSection() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_ProductSection& operator=(const Message_ListMessage_ProductSection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_ProductSection& operator=(Message_ListMessage_ProductSection&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_ProductSection& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_ProductSection* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_ProductSection*>(
+               &_Message_ListMessage_ProductSection_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    101;
+
+  friend void swap(Message_ListMessage_ProductSection& a, Message_ListMessage_ProductSection& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_ProductSection* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_ProductSection* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_ProductSection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_ProductSection>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_ProductSection& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_ProductSection& from) {
+    Message_ListMessage_ProductSection::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_ProductSection* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.ProductSection";
+  }
+  protected:
+  explicit Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductsFieldNumber = 2,
+    kTitleFieldNumber = 1,
+  };
+  // repeated .proto.Message.ListMessage.Product products = 2;
+  int products_size() const;
+  private:
+  int _internal_products_size() const;
+  public:
+  void clear_products();
+  ::proto::Message_ListMessage_Product* mutable_products(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >*
+      mutable_products();
+  private:
+  const ::proto::Message_ListMessage_Product& _internal_products(int index) const;
+  ::proto::Message_ListMessage_Product* _internal_add_products();
+  public:
+  const ::proto::Message_ListMessage_Product& products(int index) const;
+  ::proto::Message_ListMessage_Product* add_products();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >&
+      products() const;
+
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductSection)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product > products_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_Product final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Product) */ {
+ public:
+  inline Message_ListMessage_Product() : Message_ListMessage_Product(nullptr) {}
+  ~Message_ListMessage_Product() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_Product(const Message_ListMessage_Product& from);
+  Message_ListMessage_Product(Message_ListMessage_Product&& from) noexcept
+    : Message_ListMessage_Product() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_Product& operator=(const Message_ListMessage_Product& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_Product& operator=(Message_ListMessage_Product&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_Product& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_Product* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_Product*>(
+               &_Message_ListMessage_Product_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    102;
+
+  friend void swap(Message_ListMessage_Product& a, Message_ListMessage_Product& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_Product* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_Product* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_Product* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_Product>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_Product& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_Product& from) {
+    Message_ListMessage_Product::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_Product* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.Product";
+  }
+  protected:
+  explicit Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductIdFieldNumber = 1,
+  };
+  // optional string productId = 1;
+  bool has_productid() const;
+  private:
+  bool _internal_has_productid() const;
+  public:
+  void clear_productid();
+  const std::string& productid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_productid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_productid();
+  PROTOBUF_NODISCARD std::string* release_productid();
+  void set_allocated_productid(std::string* productid);
+  private:
+  const std::string& _internal_productid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
+  std::string* _internal_mutable_productid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Product)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_Row final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Row) */ {
+ public:
+  inline Message_ListMessage_Row() : Message_ListMessage_Row(nullptr) {}
+  ~Message_ListMessage_Row() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_Row(const Message_ListMessage_Row& from);
+  Message_ListMessage_Row(Message_ListMessage_Row&& from) noexcept
+    : Message_ListMessage_Row() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_Row& operator=(const Message_ListMessage_Row& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_Row& operator=(Message_ListMessage_Row&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_Row& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_Row* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_Row*>(
+               &_Message_ListMessage_Row_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    103;
+
+  friend void swap(Message_ListMessage_Row& a, Message_ListMessage_Row& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_Row* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_Row* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_Row>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_Row& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_Row& from) {
+    Message_ListMessage_Row::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_Row* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.Row";
+  }
+  protected:
+  explicit Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTitleFieldNumber = 1,
+    kDescriptionFieldNumber = 2,
+    kRowIdFieldNumber = 3,
+  };
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 2;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string rowId = 3;
+  bool has_rowid() const;
+  private:
+  bool _internal_has_rowid() const;
+  public:
+  void clear_rowid();
+  const std::string& rowid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rowid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rowid();
+  PROTOBUF_NODISCARD std::string* release_rowid();
+  void set_allocated_rowid(std::string* rowid);
+  private:
+  const std::string& _internal_rowid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rowid(const std::string& value);
+  std::string* _internal_mutable_rowid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Row)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rowid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage_Section final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Section) */ {
+ public:
+  inline Message_ListMessage_Section() : Message_ListMessage_Section(nullptr) {}
+  ~Message_ListMessage_Section() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage_Section(const Message_ListMessage_Section& from);
+  Message_ListMessage_Section(Message_ListMessage_Section&& from) noexcept
+    : Message_ListMessage_Section() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage_Section& operator=(const Message_ListMessage_Section& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage_Section& operator=(Message_ListMessage_Section&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage_Section& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage_Section* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage_Section*>(
+               &_Message_ListMessage_Section_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    104;
+
+  friend void swap(Message_ListMessage_Section& a, Message_ListMessage_Section& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage_Section* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage_Section* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage_Section* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage_Section>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage_Section& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage_Section& from) {
+    Message_ListMessage_Section::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage_Section* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage.Section";
+  }
+  protected:
+  explicit Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRowsFieldNumber = 2,
+    kTitleFieldNumber = 1,
+  };
+  // repeated .proto.Message.ListMessage.Row rows = 2;
+  int rows_size() const;
+  private:
+  int _internal_rows_size() const;
+  public:
+  void clear_rows();
+  ::proto::Message_ListMessage_Row* mutable_rows(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >*
+      mutable_rows();
+  private:
+  const ::proto::Message_ListMessage_Row& _internal_rows(int index) const;
+  ::proto::Message_ListMessage_Row* _internal_add_rows();
+  public:
+  const ::proto::Message_ListMessage_Row& rows(int index) const;
+  ::proto::Message_ListMessage_Row* add_rows();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >&
+      rows() const;
+
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Section)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row > rows_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage) */ {
+ public:
+  inline Message_ListMessage() : Message_ListMessage(nullptr) {}
+  ~Message_ListMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListMessage(const Message_ListMessage& from);
+  Message_ListMessage(Message_ListMessage&& from) noexcept
+    : Message_ListMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListMessage& operator=(const Message_ListMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListMessage& operator=(Message_ListMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ListMessage*>(
+               &_Message_ListMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    105;
+
+  friend void swap(Message_ListMessage& a, Message_ListMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListMessage& from) {
+    Message_ListMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListMessage";
+  }
+  protected:
+  explicit Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ListMessage_ProductListHeaderImage ProductListHeaderImage;
+  typedef Message_ListMessage_ProductListInfo ProductListInfo;
+  typedef Message_ListMessage_ProductSection ProductSection;
+  typedef Message_ListMessage_Product Product;
+  typedef Message_ListMessage_Row Row;
+  typedef Message_ListMessage_Section Section;
+
+  typedef Message_ListMessage_ListType ListType;
+  static constexpr ListType UNKNOWN =
+    Message_ListMessage_ListType_UNKNOWN;
+  static constexpr ListType SINGLE_SELECT =
+    Message_ListMessage_ListType_SINGLE_SELECT;
+  static constexpr ListType PRODUCT_LIST =
+    Message_ListMessage_ListType_PRODUCT_LIST;
+  static inline bool ListType_IsValid(int value) {
+    return Message_ListMessage_ListType_IsValid(value);
+  }
+  static constexpr ListType ListType_MIN =
+    Message_ListMessage_ListType_ListType_MIN;
+  static constexpr ListType ListType_MAX =
+    Message_ListMessage_ListType_ListType_MAX;
+  static constexpr int ListType_ARRAYSIZE =
+    Message_ListMessage_ListType_ListType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ListType_descriptor() {
+    return Message_ListMessage_ListType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ListType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ListType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ListType_Name.");
+    return Message_ListMessage_ListType_Name(enum_t_value);
+  }
+  static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ListType* value) {
+    return Message_ListMessage_ListType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSectionsFieldNumber = 5,
+    kTitleFieldNumber = 1,
+    kDescriptionFieldNumber = 2,
+    kButtonTextFieldNumber = 3,
+    kFooterTextFieldNumber = 7,
+    kProductListInfoFieldNumber = 6,
+    kContextInfoFieldNumber = 8,
+    kListTypeFieldNumber = 4,
+  };
+  // repeated .proto.Message.ListMessage.Section sections = 5;
+  int sections_size() const;
+  private:
+  int _internal_sections_size() const;
+  public:
+  void clear_sections();
+  ::proto::Message_ListMessage_Section* mutable_sections(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >*
+      mutable_sections();
+  private:
+  const ::proto::Message_ListMessage_Section& _internal_sections(int index) const;
+  ::proto::Message_ListMessage_Section* _internal_add_sections();
+  public:
+  const ::proto::Message_ListMessage_Section& sections(int index) const;
+  ::proto::Message_ListMessage_Section* add_sections();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >&
+      sections() const;
+
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 2;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string buttonText = 3;
+  bool has_buttontext() const;
+  private:
+  bool _internal_has_buttontext() const;
+  public:
+  void clear_buttontext();
+  const std::string& buttontext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_buttontext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_buttontext();
+  PROTOBUF_NODISCARD std::string* release_buttontext();
+  void set_allocated_buttontext(std::string* buttontext);
+  private:
+  const std::string& _internal_buttontext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontext(const std::string& value);
+  std::string* _internal_mutable_buttontext();
+  public:
+
+  // optional string footerText = 7;
+  bool has_footertext() const;
+  private:
+  bool _internal_has_footertext() const;
+  public:
+  void clear_footertext();
+  const std::string& footertext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_footertext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_footertext();
+  PROTOBUF_NODISCARD std::string* release_footertext();
+  void set_allocated_footertext(std::string* footertext);
+  private:
+  const std::string& _internal_footertext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value);
+  std::string* _internal_mutable_footertext();
+  public:
+
+  // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
+  bool has_productlistinfo() const;
+  private:
+  bool _internal_has_productlistinfo() const;
+  public:
+  void clear_productlistinfo();
+  const ::proto::Message_ListMessage_ProductListInfo& productlistinfo() const;
+  PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListInfo* release_productlistinfo();
+  ::proto::Message_ListMessage_ProductListInfo* mutable_productlistinfo();
+  void set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo);
+  private:
+  const ::proto::Message_ListMessage_ProductListInfo& _internal_productlistinfo() const;
+  ::proto::Message_ListMessage_ProductListInfo* _internal_mutable_productlistinfo();
+  public:
+  void unsafe_arena_set_allocated_productlistinfo(
+      ::proto::Message_ListMessage_ProductListInfo* productlistinfo);
+  ::proto::Message_ListMessage_ProductListInfo* unsafe_arena_release_productlistinfo();
+
+  // optional .proto.ContextInfo contextInfo = 8;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional .proto.Message.ListMessage.ListType listType = 4;
+  bool has_listtype() const;
+  private:
+  bool _internal_has_listtype() const;
+  public:
+  void clear_listtype();
+  ::proto::Message_ListMessage_ListType listtype() const;
+  void set_listtype(::proto::Message_ListMessage_ListType value);
+  private:
+  ::proto::Message_ListMessage_ListType _internal_listtype() const;
+  void _internal_set_listtype(::proto::Message_ListMessage_ListType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section > sections_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_;
+    ::proto::Message_ListMessage_ProductListInfo* productlistinfo_;
+    ::proto::ContextInfo* contextinfo_;
+    int listtype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListResponseMessage_SingleSelectReply final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage.SingleSelectReply) */ {
+ public:
+  inline Message_ListResponseMessage_SingleSelectReply() : Message_ListResponseMessage_SingleSelectReply(nullptr) {}
+  ~Message_ListResponseMessage_SingleSelectReply() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from);
+  Message_ListResponseMessage_SingleSelectReply(Message_ListResponseMessage_SingleSelectReply&& from) noexcept
+    : Message_ListResponseMessage_SingleSelectReply() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListResponseMessage_SingleSelectReply& operator=(const Message_ListResponseMessage_SingleSelectReply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListResponseMessage_SingleSelectReply& operator=(Message_ListResponseMessage_SingleSelectReply&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListResponseMessage_SingleSelectReply& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListResponseMessage_SingleSelectReply* internal_default_instance() {
+    return reinterpret_cast<const Message_ListResponseMessage_SingleSelectReply*>(
+               &_Message_ListResponseMessage_SingleSelectReply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    106;
+
+  friend void swap(Message_ListResponseMessage_SingleSelectReply& a, Message_ListResponseMessage_SingleSelectReply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListResponseMessage_SingleSelectReply* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListResponseMessage_SingleSelectReply* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListResponseMessage_SingleSelectReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListResponseMessage_SingleSelectReply>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListResponseMessage_SingleSelectReply& from) {
+    Message_ListResponseMessage_SingleSelectReply::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListResponseMessage_SingleSelectReply* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListResponseMessage.SingleSelectReply";
+  }
+  protected:
+  explicit Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectedRowIdFieldNumber = 1,
+  };
+  // optional string selectedRowId = 1;
+  bool has_selectedrowid() const;
+  private:
+  bool _internal_has_selectedrowid() const;
+  public:
+  void clear_selectedrowid();
+  const std::string& selectedrowid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_selectedrowid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_selectedrowid();
+  PROTOBUF_NODISCARD std::string* release_selectedrowid();
+  void set_allocated_selectedrowid(std::string* selectedrowid);
+  private:
+  const std::string& _internal_selectedrowid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedrowid(const std::string& value);
+  std::string* _internal_mutable_selectedrowid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage.SingleSelectReply)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedrowid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ListResponseMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage) */ {
+ public:
+  inline Message_ListResponseMessage() : Message_ListResponseMessage(nullptr) {}
+  ~Message_ListResponseMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ListResponseMessage(const Message_ListResponseMessage& from);
+  Message_ListResponseMessage(Message_ListResponseMessage&& from) noexcept
+    : Message_ListResponseMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ListResponseMessage& operator=(const Message_ListResponseMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ListResponseMessage& operator=(Message_ListResponseMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ListResponseMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ListResponseMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ListResponseMessage*>(
+               &_Message_ListResponseMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    107;
+
+  friend void swap(Message_ListResponseMessage& a, Message_ListResponseMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ListResponseMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ListResponseMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ListResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ListResponseMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ListResponseMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ListResponseMessage& from) {
+    Message_ListResponseMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ListResponseMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ListResponseMessage";
+  }
+  protected:
+  explicit Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ListResponseMessage_SingleSelectReply SingleSelectReply;
+
+  typedef Message_ListResponseMessage_ListType ListType;
+  static constexpr ListType UNKNOWN =
+    Message_ListResponseMessage_ListType_UNKNOWN;
+  static constexpr ListType SINGLE_SELECT =
+    Message_ListResponseMessage_ListType_SINGLE_SELECT;
+  static inline bool ListType_IsValid(int value) {
+    return Message_ListResponseMessage_ListType_IsValid(value);
+  }
+  static constexpr ListType ListType_MIN =
+    Message_ListResponseMessage_ListType_ListType_MIN;
+  static constexpr ListType ListType_MAX =
+    Message_ListResponseMessage_ListType_ListType_MAX;
+  static constexpr int ListType_ARRAYSIZE =
+    Message_ListResponseMessage_ListType_ListType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ListType_descriptor() {
+    return Message_ListResponseMessage_ListType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ListType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ListType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ListType_Name.");
+    return Message_ListResponseMessage_ListType_Name(enum_t_value);
+  }
+  static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ListType* value) {
+    return Message_ListResponseMessage_ListType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTitleFieldNumber = 1,
+    kDescriptionFieldNumber = 5,
+    kSingleSelectReplyFieldNumber = 3,
+    kContextInfoFieldNumber = 4,
+    kListTypeFieldNumber = 2,
+  };
+  // optional string title = 1;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 5;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
+  bool has_singleselectreply() const;
+  private:
+  bool _internal_has_singleselectreply() const;
+  public:
+  void clear_singleselectreply();
+  const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply() const;
+  PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage_SingleSelectReply* release_singleselectreply();
+  ::proto::Message_ListResponseMessage_SingleSelectReply* mutable_singleselectreply();
+  void set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply);
+  private:
+  const ::proto::Message_ListResponseMessage_SingleSelectReply& _internal_singleselectreply() const;
+  ::proto::Message_ListResponseMessage_SingleSelectReply* _internal_mutable_singleselectreply();
+  public:
+  void unsafe_arena_set_allocated_singleselectreply(
+      ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply);
+  ::proto::Message_ListResponseMessage_SingleSelectReply* unsafe_arena_release_singleselectreply();
+
+  // optional .proto.ContextInfo contextInfo = 4;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional .proto.Message.ListResponseMessage.ListType listType = 2;
+  bool has_listtype() const;
+  private:
+  bool _internal_has_listtype() const;
+  public:
+  void clear_listtype();
+  ::proto::Message_ListResponseMessage_ListType listtype() const;
+  void set_listtype(::proto::Message_ListResponseMessage_ListType value);
+  private:
+  ::proto::Message_ListResponseMessage_ListType _internal_listtype() const;
+  void _internal_set_listtype(::proto::Message_ListResponseMessage_ListType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply_;
+    ::proto::ContextInfo* contextinfo_;
+    int listtype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_LiveLocationMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LiveLocationMessage) */ {
+ public:
+  inline Message_LiveLocationMessage() : Message_LiveLocationMessage(nullptr) {}
+  ~Message_LiveLocationMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_LiveLocationMessage(const Message_LiveLocationMessage& from);
+  Message_LiveLocationMessage(Message_LiveLocationMessage&& from) noexcept
+    : Message_LiveLocationMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_LiveLocationMessage& operator=(const Message_LiveLocationMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_LiveLocationMessage& operator=(Message_LiveLocationMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_LiveLocationMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_LiveLocationMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_LiveLocationMessage*>(
+               &_Message_LiveLocationMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    108;
+
+  friend void swap(Message_LiveLocationMessage& a, Message_LiveLocationMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_LiveLocationMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_LiveLocationMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_LiveLocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_LiveLocationMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_LiveLocationMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_LiveLocationMessage& from) {
+    Message_LiveLocationMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_LiveLocationMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.LiveLocationMessage";
+  }
+  protected:
+  explicit Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCaptionFieldNumber = 6,
+    kJpegThumbnailFieldNumber = 16,
+    kContextInfoFieldNumber = 17,
+    kDegreesLatitudeFieldNumber = 1,
+    kDegreesLongitudeFieldNumber = 2,
+    kAccuracyInMetersFieldNumber = 3,
+    kSpeedInMpsFieldNumber = 4,
+    kDegreesClockwiseFromMagneticNorthFieldNumber = 5,
+    kTimeOffsetFieldNumber = 8,
+    kSequenceNumberFieldNumber = 7,
+  };
+  // optional string caption = 6;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional double degreesLatitude = 1;
+  bool has_degreeslatitude() const;
+  private:
+  bool _internal_has_degreeslatitude() const;
+  public:
+  void clear_degreeslatitude();
+  double degreeslatitude() const;
+  void set_degreeslatitude(double value);
+  private:
+  double _internal_degreeslatitude() const;
+  void _internal_set_degreeslatitude(double value);
+  public:
+
+  // optional double degreesLongitude = 2;
+  bool has_degreeslongitude() const;
+  private:
+  bool _internal_has_degreeslongitude() const;
+  public:
+  void clear_degreeslongitude();
+  double degreeslongitude() const;
+  void set_degreeslongitude(double value);
+  private:
+  double _internal_degreeslongitude() const;
+  void _internal_set_degreeslongitude(double value);
+  public:
+
+  // optional uint32 accuracyInMeters = 3;
+  bool has_accuracyinmeters() const;
+  private:
+  bool _internal_has_accuracyinmeters() const;
+  public:
+  void clear_accuracyinmeters();
+  uint32_t accuracyinmeters() const;
+  void set_accuracyinmeters(uint32_t value);
+  private:
+  uint32_t _internal_accuracyinmeters() const;
+  void _internal_set_accuracyinmeters(uint32_t value);
+  public:
+
+  // optional float speedInMps = 4;
+  bool has_speedinmps() const;
+  private:
+  bool _internal_has_speedinmps() const;
+  public:
+  void clear_speedinmps();
+  float speedinmps() const;
+  void set_speedinmps(float value);
+  private:
+  float _internal_speedinmps() const;
+  void _internal_set_speedinmps(float value);
+  public:
+
+  // optional uint32 degreesClockwiseFromMagneticNorth = 5;
+  bool has_degreesclockwisefrommagneticnorth() const;
+  private:
+  bool _internal_has_degreesclockwisefrommagneticnorth() const;
+  public:
+  void clear_degreesclockwisefrommagneticnorth();
+  uint32_t degreesclockwisefrommagneticnorth() const;
+  void set_degreesclockwisefrommagneticnorth(uint32_t value);
+  private:
+  uint32_t _internal_degreesclockwisefrommagneticnorth() const;
+  void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value);
+  public:
+
+  // optional uint32 timeOffset = 8;
+  bool has_timeoffset() const;
+  private:
+  bool _internal_has_timeoffset() const;
+  public:
+  void clear_timeoffset();
+  uint32_t timeoffset() const;
+  void set_timeoffset(uint32_t value);
+  private:
+  uint32_t _internal_timeoffset() const;
+  void _internal_set_timeoffset(uint32_t value);
+  public:
+
+  // optional int64 sequenceNumber = 7;
+  bool has_sequencenumber() const;
+  private:
+  bool _internal_has_sequencenumber() const;
+  public:
+  void clear_sequencenumber();
+  int64_t sequencenumber() const;
+  void set_sequencenumber(int64_t value);
+  private:
+  int64_t _internal_sequencenumber() const;
+  void _internal_set_sequencenumber(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.LiveLocationMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::proto::ContextInfo* contextinfo_;
+    double degreeslatitude_;
+    double degreeslongitude_;
+    uint32_t accuracyinmeters_;
+    float speedinmps_;
+    uint32_t degreesclockwisefrommagneticnorth_;
+    uint32_t timeoffset_;
+    int64_t sequencenumber_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_LocationMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LocationMessage) */ {
+ public:
+  inline Message_LocationMessage() : Message_LocationMessage(nullptr) {}
+  ~Message_LocationMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_LocationMessage(const Message_LocationMessage& from);
+  Message_LocationMessage(Message_LocationMessage&& from) noexcept
+    : Message_LocationMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_LocationMessage& operator=(const Message_LocationMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_LocationMessage& operator=(Message_LocationMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_LocationMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_LocationMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_LocationMessage*>(
+               &_Message_LocationMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    109;
+
+  friend void swap(Message_LocationMessage& a, Message_LocationMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_LocationMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_LocationMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_LocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_LocationMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_LocationMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_LocationMessage& from) {
+    Message_LocationMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_LocationMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.LocationMessage";
+  }
+  protected:
+  explicit Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 3,
+    kAddressFieldNumber = 4,
+    kUrlFieldNumber = 5,
+    kCommentFieldNumber = 11,
+    kJpegThumbnailFieldNumber = 16,
+    kContextInfoFieldNumber = 17,
+    kDegreesLatitudeFieldNumber = 1,
+    kDegreesLongitudeFieldNumber = 2,
+    kIsLiveFieldNumber = 6,
+    kAccuracyInMetersFieldNumber = 7,
+    kSpeedInMpsFieldNumber = 8,
+    kDegreesClockwiseFromMagneticNorthFieldNumber = 9,
+  };
+  // optional string name = 3;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string address = 4;
+  bool has_address() const;
+  private:
+  bool _internal_has_address() const;
+  public:
+  void clear_address();
+  const std::string& address() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_address(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_address();
+  PROTOBUF_NODISCARD std::string* release_address();
+  void set_allocated_address(std::string* address);
+  private:
+  const std::string& _internal_address() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value);
+  std::string* _internal_mutable_address();
+  public:
+
+  // optional string url = 5;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string comment = 11;
+  bool has_comment() const;
+  private:
+  bool _internal_has_comment() const;
+  public:
+  void clear_comment();
+  const std::string& comment() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_comment(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_comment();
+  PROTOBUF_NODISCARD std::string* release_comment();
+  void set_allocated_comment(std::string* comment);
+  private:
+  const std::string& _internal_comment() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);
+  std::string* _internal_mutable_comment();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional double degreesLatitude = 1;
+  bool has_degreeslatitude() const;
+  private:
+  bool _internal_has_degreeslatitude() const;
+  public:
+  void clear_degreeslatitude();
+  double degreeslatitude() const;
+  void set_degreeslatitude(double value);
+  private:
+  double _internal_degreeslatitude() const;
+  void _internal_set_degreeslatitude(double value);
+  public:
+
+  // optional double degreesLongitude = 2;
+  bool has_degreeslongitude() const;
+  private:
+  bool _internal_has_degreeslongitude() const;
+  public:
+  void clear_degreeslongitude();
+  double degreeslongitude() const;
+  void set_degreeslongitude(double value);
+  private:
+  double _internal_degreeslongitude() const;
+  void _internal_set_degreeslongitude(double value);
+  public:
+
+  // optional bool isLive = 6;
+  bool has_islive() const;
+  private:
+  bool _internal_has_islive() const;
+  public:
+  void clear_islive();
+  bool islive() const;
+  void set_islive(bool value);
+  private:
+  bool _internal_islive() const;
+  void _internal_set_islive(bool value);
+  public:
+
+  // optional uint32 accuracyInMeters = 7;
+  bool has_accuracyinmeters() const;
+  private:
+  bool _internal_has_accuracyinmeters() const;
+  public:
+  void clear_accuracyinmeters();
+  uint32_t accuracyinmeters() const;
+  void set_accuracyinmeters(uint32_t value);
+  private:
+  uint32_t _internal_accuracyinmeters() const;
+  void _internal_set_accuracyinmeters(uint32_t value);
+  public:
+
+  // optional float speedInMps = 8;
+  bool has_speedinmps() const;
+  private:
+  bool _internal_has_speedinmps() const;
+  public:
+  void clear_speedinmps();
+  float speedinmps() const;
+  void set_speedinmps(float value);
+  private:
+  float _internal_speedinmps() const;
+  void _internal_set_speedinmps(float value);
+  public:
+
+  // optional uint32 degreesClockwiseFromMagneticNorth = 9;
+  bool has_degreesclockwisefrommagneticnorth() const;
+  private:
+  bool _internal_has_degreesclockwisefrommagneticnorth() const;
+  public:
+  void clear_degreesclockwisefrommagneticnorth();
+  uint32_t degreesclockwisefrommagneticnorth() const;
+  void set_degreesclockwisefrommagneticnorth(uint32_t value);
+  private:
+  uint32_t _internal_degreesclockwisefrommagneticnorth() const;
+  void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.LocationMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::proto::ContextInfo* contextinfo_;
+    double degreeslatitude_;
+    double degreeslongitude_;
+    bool islive_;
+    uint32_t accuracyinmeters_;
+    float speedinmps_;
+    uint32_t degreesclockwisefrommagneticnorth_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_OrderMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.OrderMessage) */ {
+ public:
+  inline Message_OrderMessage() : Message_OrderMessage(nullptr) {}
+  ~Message_OrderMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_OrderMessage(const Message_OrderMessage& from);
+  Message_OrderMessage(Message_OrderMessage&& from) noexcept
+    : Message_OrderMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_OrderMessage& operator=(const Message_OrderMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_OrderMessage& operator=(Message_OrderMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_OrderMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_OrderMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_OrderMessage*>(
+               &_Message_OrderMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    110;
+
+  friend void swap(Message_OrderMessage& a, Message_OrderMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_OrderMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_OrderMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_OrderMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_OrderMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_OrderMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_OrderMessage& from) {
+    Message_OrderMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_OrderMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.OrderMessage";
+  }
+  protected:
+  explicit Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_OrderMessage_OrderStatus OrderStatus;
+  static constexpr OrderStatus INQUIRY =
+    Message_OrderMessage_OrderStatus_INQUIRY;
+  static inline bool OrderStatus_IsValid(int value) {
+    return Message_OrderMessage_OrderStatus_IsValid(value);
+  }
+  static constexpr OrderStatus OrderStatus_MIN =
+    Message_OrderMessage_OrderStatus_OrderStatus_MIN;
+  static constexpr OrderStatus OrderStatus_MAX =
+    Message_OrderMessage_OrderStatus_OrderStatus_MAX;
+  static constexpr int OrderStatus_ARRAYSIZE =
+    Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  OrderStatus_descriptor() {
+    return Message_OrderMessage_OrderStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& OrderStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, OrderStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function OrderStatus_Name.");
+    return Message_OrderMessage_OrderStatus_Name(enum_t_value);
+  }
+  static inline bool OrderStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      OrderStatus* value) {
+    return Message_OrderMessage_OrderStatus_Parse(name, value);
+  }
+
+  typedef Message_OrderMessage_OrderSurface OrderSurface;
+  static constexpr OrderSurface CATALOG =
+    Message_OrderMessage_OrderSurface_CATALOG;
+  static inline bool OrderSurface_IsValid(int value) {
+    return Message_OrderMessage_OrderSurface_IsValid(value);
+  }
+  static constexpr OrderSurface OrderSurface_MIN =
+    Message_OrderMessage_OrderSurface_OrderSurface_MIN;
+  static constexpr OrderSurface OrderSurface_MAX =
+    Message_OrderMessage_OrderSurface_OrderSurface_MAX;
+  static constexpr int OrderSurface_ARRAYSIZE =
+    Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  OrderSurface_descriptor() {
+    return Message_OrderMessage_OrderSurface_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& OrderSurface_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, OrderSurface>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function OrderSurface_Name.");
+    return Message_OrderMessage_OrderSurface_Name(enum_t_value);
+  }
+  static inline bool OrderSurface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      OrderSurface* value) {
+    return Message_OrderMessage_OrderSurface_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOrderIdFieldNumber = 1,
+    kThumbnailFieldNumber = 2,
+    kMessageFieldNumber = 6,
+    kOrderTitleFieldNumber = 7,
+    kSellerJidFieldNumber = 8,
+    kTokenFieldNumber = 9,
+    kTotalCurrencyCodeFieldNumber = 11,
+    kContextInfoFieldNumber = 17,
+    kTotalAmount1000FieldNumber = 10,
+    kItemCountFieldNumber = 3,
+    kStatusFieldNumber = 4,
+    kSurfaceFieldNumber = 5,
+  };
+  // optional string orderId = 1;
+  bool has_orderid() const;
+  private:
+  bool _internal_has_orderid() const;
+  public:
+  void clear_orderid();
+  const std::string& orderid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_orderid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_orderid();
+  PROTOBUF_NODISCARD std::string* release_orderid();
+  void set_allocated_orderid(std::string* orderid);
+  private:
+  const std::string& _internal_orderid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_orderid(const std::string& value);
+  std::string* _internal_mutable_orderid();
+  public:
+
+  // optional bytes thumbnail = 2;
+  bool has_thumbnail() const;
+  private:
+  bool _internal_has_thumbnail() const;
+  public:
+  void clear_thumbnail();
+  const std::string& thumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnail();
+  PROTOBUF_NODISCARD std::string* release_thumbnail();
+  void set_allocated_thumbnail(std::string* thumbnail);
+  private:
+  const std::string& _internal_thumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value);
+  std::string* _internal_mutable_thumbnail();
+  public:
+
+  // optional string message = 6;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const std::string& message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_message();
+  PROTOBUF_NODISCARD std::string* release_message();
+  void set_allocated_message(std::string* message);
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+  std::string* _internal_mutable_message();
+  public:
+
+  // optional string orderTitle = 7;
+  bool has_ordertitle() const;
+  private:
+  bool _internal_has_ordertitle() const;
+  public:
+  void clear_ordertitle();
+  const std::string& ordertitle() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ordertitle(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ordertitle();
+  PROTOBUF_NODISCARD std::string* release_ordertitle();
+  void set_allocated_ordertitle(std::string* ordertitle);
+  private:
+  const std::string& _internal_ordertitle() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ordertitle(const std::string& value);
+  std::string* _internal_mutable_ordertitle();
+  public:
+
+  // optional string sellerJid = 8;
+  bool has_sellerjid() const;
+  private:
+  bool _internal_has_sellerjid() const;
+  public:
+  void clear_sellerjid();
+  const std::string& sellerjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sellerjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sellerjid();
+  PROTOBUF_NODISCARD std::string* release_sellerjid();
+  void set_allocated_sellerjid(std::string* sellerjid);
+  private:
+  const std::string& _internal_sellerjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sellerjid(const std::string& value);
+  std::string* _internal_mutable_sellerjid();
+  public:
+
+  // optional string token = 9;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional string totalCurrencyCode = 11;
+  bool has_totalcurrencycode() const;
+  private:
+  bool _internal_has_totalcurrencycode() const;
+  public:
+  void clear_totalcurrencycode();
+  const std::string& totalcurrencycode() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_totalcurrencycode(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_totalcurrencycode();
+  PROTOBUF_NODISCARD std::string* release_totalcurrencycode();
+  void set_allocated_totalcurrencycode(std::string* totalcurrencycode);
+  private:
+  const std::string& _internal_totalcurrencycode() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_totalcurrencycode(const std::string& value);
+  std::string* _internal_mutable_totalcurrencycode();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional int64 totalAmount1000 = 10;
+  bool has_totalamount1000() const;
+  private:
+  bool _internal_has_totalamount1000() const;
+  public:
+  void clear_totalamount1000();
+  int64_t totalamount1000() const;
+  void set_totalamount1000(int64_t value);
+  private:
+  int64_t _internal_totalamount1000() const;
+  void _internal_set_totalamount1000(int64_t value);
+  public:
+
+  // optional int32 itemCount = 3;
+  bool has_itemcount() const;
+  private:
+  bool _internal_has_itemcount() const;
+  public:
+  void clear_itemcount();
+  int32_t itemcount() const;
+  void set_itemcount(int32_t value);
+  private:
+  int32_t _internal_itemcount() const;
+  void _internal_set_itemcount(int32_t value);
+  public:
+
+  // optional .proto.Message.OrderMessage.OrderStatus status = 4;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::proto::Message_OrderMessage_OrderStatus status() const;
+  void set_status(::proto::Message_OrderMessage_OrderStatus value);
+  private:
+  ::proto::Message_OrderMessage_OrderStatus _internal_status() const;
+  void _internal_set_status(::proto::Message_OrderMessage_OrderStatus value);
+  public:
+
+  // optional .proto.Message.OrderMessage.OrderSurface surface = 5;
+  bool has_surface() const;
+  private:
+  bool _internal_has_surface() const;
+  public:
+  void clear_surface();
+  ::proto::Message_OrderMessage_OrderSurface surface() const;
+  void set_surface(::proto::Message_OrderMessage_OrderSurface value);
+  private:
+  ::proto::Message_OrderMessage_OrderSurface _internal_surface() const;
+  void _internal_set_surface(::proto::Message_OrderMessage_OrderSurface value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.OrderMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orderid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ordertitle_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sellerjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr totalcurrencycode_;
+    ::proto::ContextInfo* contextinfo_;
+    int64_t totalamount1000_;
+    int32_t itemcount_;
+    int status_;
+    int surface_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PaymentInviteMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PaymentInviteMessage) */ {
+ public:
+  inline Message_PaymentInviteMessage() : Message_PaymentInviteMessage(nullptr) {}
+  ~Message_PaymentInviteMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from);
+  Message_PaymentInviteMessage(Message_PaymentInviteMessage&& from) noexcept
+    : Message_PaymentInviteMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PaymentInviteMessage& operator=(const Message_PaymentInviteMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PaymentInviteMessage& operator=(Message_PaymentInviteMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PaymentInviteMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PaymentInviteMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_PaymentInviteMessage*>(
+               &_Message_PaymentInviteMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    111;
+
+  friend void swap(Message_PaymentInviteMessage& a, Message_PaymentInviteMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PaymentInviteMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PaymentInviteMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PaymentInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PaymentInviteMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PaymentInviteMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PaymentInviteMessage& from) {
+    Message_PaymentInviteMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PaymentInviteMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PaymentInviteMessage";
+  }
+  protected:
+  explicit Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_PaymentInviteMessage_ServiceType ServiceType;
+  static constexpr ServiceType UNKNOWN =
+    Message_PaymentInviteMessage_ServiceType_UNKNOWN;
+  static constexpr ServiceType FBPAY =
+    Message_PaymentInviteMessage_ServiceType_FBPAY;
+  static constexpr ServiceType NOVI =
+    Message_PaymentInviteMessage_ServiceType_NOVI;
+  static constexpr ServiceType UPI =
+    Message_PaymentInviteMessage_ServiceType_UPI;
+  static inline bool ServiceType_IsValid(int value) {
+    return Message_PaymentInviteMessage_ServiceType_IsValid(value);
+  }
+  static constexpr ServiceType ServiceType_MIN =
+    Message_PaymentInviteMessage_ServiceType_ServiceType_MIN;
+  static constexpr ServiceType ServiceType_MAX =
+    Message_PaymentInviteMessage_ServiceType_ServiceType_MAX;
+  static constexpr int ServiceType_ARRAYSIZE =
+    Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ServiceType_descriptor() {
+    return Message_PaymentInviteMessage_ServiceType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ServiceType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ServiceType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ServiceType_Name.");
+    return Message_PaymentInviteMessage_ServiceType_Name(enum_t_value);
+  }
+  static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ServiceType* value) {
+    return Message_PaymentInviteMessage_ServiceType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpiryTimestampFieldNumber = 2,
+    kServiceTypeFieldNumber = 1,
+  };
+  // optional int64 expiryTimestamp = 2;
+  bool has_expirytimestamp() const;
+  private:
+  bool _internal_has_expirytimestamp() const;
+  public:
+  void clear_expirytimestamp();
+  int64_t expirytimestamp() const;
+  void set_expirytimestamp(int64_t value);
+  private:
+  int64_t _internal_expirytimestamp() const;
+  void _internal_set_expirytimestamp(int64_t value);
+  public:
+
+  // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
+  bool has_servicetype() const;
+  private:
+  bool _internal_has_servicetype() const;
+  public:
+  void clear_servicetype();
+  ::proto::Message_PaymentInviteMessage_ServiceType servicetype() const;
+  void set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value);
+  private:
+  ::proto::Message_PaymentInviteMessage_ServiceType _internal_servicetype() const;
+  void _internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PaymentInviteMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t expirytimestamp_;
+    int servicetype_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollCreationMessage_Option final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage.Option) */ {
+ public:
+  inline Message_PollCreationMessage_Option() : Message_PollCreationMessage_Option(nullptr) {}
+  ~Message_PollCreationMessage_Option() override;
+  explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from);
+  Message_PollCreationMessage_Option(Message_PollCreationMessage_Option&& from) noexcept
+    : Message_PollCreationMessage_Option() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollCreationMessage_Option& operator=(const Message_PollCreationMessage_Option& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollCreationMessage_Option& operator=(Message_PollCreationMessage_Option&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollCreationMessage_Option& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollCreationMessage_Option* internal_default_instance() {
+    return reinterpret_cast<const Message_PollCreationMessage_Option*>(
+               &_Message_PollCreationMessage_Option_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    112;
+
+  friend void swap(Message_PollCreationMessage_Option& a, Message_PollCreationMessage_Option& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollCreationMessage_Option* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollCreationMessage_Option* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollCreationMessage_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollCreationMessage_Option>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PollCreationMessage_Option& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PollCreationMessage_Option& from) {
+    Message_PollCreationMessage_Option::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PollCreationMessage_Option* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollCreationMessage.Option";
+  }
+  protected:
+  explicit Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionNameFieldNumber = 1,
+  };
+  // optional string optionName = 1;
+  bool has_optionname() const;
+  private:
+  bool _internal_has_optionname() const;
+  public:
+  void clear_optionname();
+  const std::string& optionname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_optionname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_optionname();
+  PROTOBUF_NODISCARD std::string* release_optionname();
+  void set_allocated_optionname(std::string* optionname);
+  private:
+  const std::string& _internal_optionname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_optionname(const std::string& value);
+  std::string* _internal_mutable_optionname();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage.Option)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optionname_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollCreationMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage) */ {
+ public:
+  inline Message_PollCreationMessage() : Message_PollCreationMessage(nullptr) {}
+  ~Message_PollCreationMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollCreationMessage(const Message_PollCreationMessage& from);
+  Message_PollCreationMessage(Message_PollCreationMessage&& from) noexcept
+    : Message_PollCreationMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollCreationMessage& operator=(const Message_PollCreationMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollCreationMessage& operator=(Message_PollCreationMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollCreationMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollCreationMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_PollCreationMessage*>(
+               &_Message_PollCreationMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    113;
+
+  friend void swap(Message_PollCreationMessage& a, Message_PollCreationMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollCreationMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollCreationMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollCreationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollCreationMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PollCreationMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PollCreationMessage& from) {
+    Message_PollCreationMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PollCreationMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollCreationMessage";
+  }
+  protected:
+  explicit Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_PollCreationMessage_Option Option;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 3,
+    kEncKeyFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kContextInfoFieldNumber = 5,
+    kSelectableOptionsCountFieldNumber = 4,
+  };
+  // repeated .proto.Message.PollCreationMessage.Option options = 3;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::proto::Message_PollCreationMessage_Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >*
+      mutable_options();
+  private:
+  const ::proto::Message_PollCreationMessage_Option& _internal_options(int index) const;
+  ::proto::Message_PollCreationMessage_Option* _internal_add_options();
+  public:
+  const ::proto::Message_PollCreationMessage_Option& options(int index) const;
+  ::proto::Message_PollCreationMessage_Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >&
+      options() const;
+
+  // optional bytes encKey = 1;
+  bool has_enckey() const;
+  private:
+  bool _internal_has_enckey() const;
+  public:
+  void clear_enckey();
+  const std::string& enckey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_enckey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_enckey();
+  PROTOBUF_NODISCARD std::string* release_enckey();
+  void set_allocated_enckey(std::string* enckey);
+  private:
+  const std::string& _internal_enckey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enckey(const std::string& value);
+  std::string* _internal_mutable_enckey();
+  public:
+
+  // optional string name = 2;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 5;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint32 selectableOptionsCount = 4;
+  bool has_selectableoptionscount() const;
+  private:
+  bool _internal_has_selectableoptionscount() const;
+  public:
+  void clear_selectableoptionscount();
+  uint32_t selectableoptionscount() const;
+  void set_selectableoptionscount(uint32_t value);
+  private:
+  uint32_t _internal_selectableoptionscount() const;
+  void _internal_set_selectableoptionscount(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enckey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::proto::ContextInfo* contextinfo_;
+    uint32_t selectableoptionscount_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollEncValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollEncValue) */ {
+ public:
+  inline Message_PollEncValue() : Message_PollEncValue(nullptr) {}
+  ~Message_PollEncValue() override;
+  explicit PROTOBUF_CONSTEXPR Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollEncValue(const Message_PollEncValue& from);
+  Message_PollEncValue(Message_PollEncValue&& from) noexcept
+    : Message_PollEncValue() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollEncValue& operator=(const Message_PollEncValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollEncValue& operator=(Message_PollEncValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollEncValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollEncValue* internal_default_instance() {
+    return reinterpret_cast<const Message_PollEncValue*>(
+               &_Message_PollEncValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    114;
+
+  friend void swap(Message_PollEncValue& a, Message_PollEncValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollEncValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollEncValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollEncValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PollEncValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PollEncValue& from) {
+    Message_PollEncValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PollEncValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollEncValue";
+  }
+  protected:
+  explicit Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncPayloadFieldNumber = 1,
+    kEncIvFieldNumber = 2,
+  };
+  // optional bytes encPayload = 1;
+  bool has_encpayload() const;
+  private:
+  bool _internal_has_encpayload() const;
+  public:
+  void clear_encpayload();
+  const std::string& encpayload() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encpayload(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encpayload();
+  PROTOBUF_NODISCARD std::string* release_encpayload();
+  void set_allocated_encpayload(std::string* encpayload);
+  private:
+  const std::string& _internal_encpayload() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value);
+  std::string* _internal_mutable_encpayload();
+  public:
+
+  // optional bytes encIv = 2;
+  bool has_enciv() const;
+  private:
+  bool _internal_has_enciv() const;
+  public:
+  void clear_enciv();
+  const std::string& enciv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_enciv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_enciv();
+  PROTOBUF_NODISCARD std::string* release_enciv();
+  void set_allocated_enciv(std::string* enciv);
+  private:
+  const std::string& _internal_enciv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value);
+  std::string* _internal_mutable_enciv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollEncValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollUpdateMessageMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessageMetadata) */ {
+ public:
+  inline Message_PollUpdateMessageMetadata() : Message_PollUpdateMessageMetadata(nullptr) {}
+  explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from);
+  Message_PollUpdateMessageMetadata(Message_PollUpdateMessageMetadata&& from) noexcept
+    : Message_PollUpdateMessageMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollUpdateMessageMetadata& operator=(const Message_PollUpdateMessageMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollUpdateMessageMetadata& operator=(Message_PollUpdateMessageMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollUpdateMessageMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollUpdateMessageMetadata* internal_default_instance() {
+    return reinterpret_cast<const Message_PollUpdateMessageMetadata*>(
+               &_Message_PollUpdateMessageMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    115;
+
+  friend void swap(Message_PollUpdateMessageMetadata& a, Message_PollUpdateMessageMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollUpdateMessageMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollUpdateMessageMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollUpdateMessageMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollUpdateMessageMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Message_PollUpdateMessageMetadata& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Message_PollUpdateMessageMetadata& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollUpdateMessageMetadata";
+  }
+  protected:
+  explicit Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessageMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+  };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollUpdateMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessage) */ {
+ public:
+  inline Message_PollUpdateMessage() : Message_PollUpdateMessage(nullptr) {}
+  ~Message_PollUpdateMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollUpdateMessage(const Message_PollUpdateMessage& from);
+  Message_PollUpdateMessage(Message_PollUpdateMessage&& from) noexcept
+    : Message_PollUpdateMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollUpdateMessage& operator=(const Message_PollUpdateMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollUpdateMessage& operator=(Message_PollUpdateMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollUpdateMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollUpdateMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_PollUpdateMessage*>(
+               &_Message_PollUpdateMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    116;
+
+  friend void swap(Message_PollUpdateMessage& a, Message_PollUpdateMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollUpdateMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollUpdateMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollUpdateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollUpdateMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PollUpdateMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PollUpdateMessage& from) {
+    Message_PollUpdateMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PollUpdateMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollUpdateMessage";
+  }
+  protected:
+  explicit Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPollCreationMessageKeyFieldNumber = 1,
+    kVoteFieldNumber = 2,
+    kMetadataFieldNumber = 3,
+    kSenderTimestampMsFieldNumber = 4,
+  };
+  // optional .proto.MessageKey pollCreationMessageKey = 1;
+  bool has_pollcreationmessagekey() const;
+  private:
+  bool _internal_has_pollcreationmessagekey() const;
+  public:
+  void clear_pollcreationmessagekey();
+  const ::proto::MessageKey& pollcreationmessagekey() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_pollcreationmessagekey();
+  ::proto::MessageKey* mutable_pollcreationmessagekey();
+  void set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey);
+  private:
+  const ::proto::MessageKey& _internal_pollcreationmessagekey() const;
+  ::proto::MessageKey* _internal_mutable_pollcreationmessagekey();
+  public:
+  void unsafe_arena_set_allocated_pollcreationmessagekey(
+      ::proto::MessageKey* pollcreationmessagekey);
+  ::proto::MessageKey* unsafe_arena_release_pollcreationmessagekey();
+
+  // optional .proto.Message.PollEncValue vote = 2;
+  bool has_vote() const;
+  private:
+  bool _internal_has_vote() const;
+  public:
+  void clear_vote();
+  const ::proto::Message_PollEncValue& vote() const;
+  PROTOBUF_NODISCARD ::proto::Message_PollEncValue* release_vote();
+  ::proto::Message_PollEncValue* mutable_vote();
+  void set_allocated_vote(::proto::Message_PollEncValue* vote);
+  private:
+  const ::proto::Message_PollEncValue& _internal_vote() const;
+  ::proto::Message_PollEncValue* _internal_mutable_vote();
+  public:
+  void unsafe_arena_set_allocated_vote(
+      ::proto::Message_PollEncValue* vote);
+  ::proto::Message_PollEncValue* unsafe_arena_release_vote();
+
+  // optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
+  bool has_metadata() const;
+  private:
+  bool _internal_has_metadata() const;
+  public:
+  void clear_metadata();
+  const ::proto::Message_PollUpdateMessageMetadata& metadata() const;
+  PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessageMetadata* release_metadata();
+  ::proto::Message_PollUpdateMessageMetadata* mutable_metadata();
+  void set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata);
+  private:
+  const ::proto::Message_PollUpdateMessageMetadata& _internal_metadata() const;
+  ::proto::Message_PollUpdateMessageMetadata* _internal_mutable_metadata();
+  public:
+  void unsafe_arena_set_allocated_metadata(
+      ::proto::Message_PollUpdateMessageMetadata* metadata);
+  ::proto::Message_PollUpdateMessageMetadata* unsafe_arena_release_metadata();
+
+  // optional int64 senderTimestampMs = 4;
+  bool has_sendertimestampms() const;
+  private:
+  bool _internal_has_sendertimestampms() const;
+  public:
+  void clear_sendertimestampms();
+  int64_t sendertimestampms() const;
+  void set_sendertimestampms(int64_t value);
+  private:
+  int64_t _internal_sendertimestampms() const;
+  void _internal_set_sendertimestampms(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* pollcreationmessagekey_;
+    ::proto::Message_PollEncValue* vote_;
+    ::proto::Message_PollUpdateMessageMetadata* metadata_;
+    int64_t sendertimestampms_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_PollVoteMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollVoteMessage) */ {
+ public:
+  inline Message_PollVoteMessage() : Message_PollVoteMessage(nullptr) {}
+  ~Message_PollVoteMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_PollVoteMessage(const Message_PollVoteMessage& from);
+  Message_PollVoteMessage(Message_PollVoteMessage&& from) noexcept
+    : Message_PollVoteMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_PollVoteMessage& operator=(const Message_PollVoteMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_PollVoteMessage& operator=(Message_PollVoteMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_PollVoteMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_PollVoteMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_PollVoteMessage*>(
+               &_Message_PollVoteMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    117;
+
+  friend void swap(Message_PollVoteMessage& a, Message_PollVoteMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_PollVoteMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_PollVoteMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_PollVoteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_PollVoteMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_PollVoteMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_PollVoteMessage& from) {
+    Message_PollVoteMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_PollVoteMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.PollVoteMessage";
+  }
+  protected:
+  explicit Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectedOptionsFieldNumber = 1,
+  };
+  // repeated bytes selectedOptions = 1;
+  int selectedoptions_size() const;
+  private:
+  int _internal_selectedoptions_size() const;
+  public:
+  void clear_selectedoptions();
+  const std::string& selectedoptions(int index) const;
+  std::string* mutable_selectedoptions(int index);
+  void set_selectedoptions(int index, const std::string& value);
+  void set_selectedoptions(int index, std::string&& value);
+  void set_selectedoptions(int index, const char* value);
+  void set_selectedoptions(int index, const void* value, size_t size);
+  std::string* add_selectedoptions();
+  void add_selectedoptions(const std::string& value);
+  void add_selectedoptions(std::string&& value);
+  void add_selectedoptions(const char* value);
+  void add_selectedoptions(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& selectedoptions() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_selectedoptions();
+  private:
+  const std::string& _internal_selectedoptions(int index) const;
+  std::string* _internal_add_selectedoptions();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.PollVoteMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> selectedoptions_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ProductMessage_CatalogSnapshot final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.CatalogSnapshot) */ {
+ public:
+  inline Message_ProductMessage_CatalogSnapshot() : Message_ProductMessage_CatalogSnapshot(nullptr) {}
+  ~Message_ProductMessage_CatalogSnapshot() override;
+  explicit PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from);
+  Message_ProductMessage_CatalogSnapshot(Message_ProductMessage_CatalogSnapshot&& from) noexcept
+    : Message_ProductMessage_CatalogSnapshot() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ProductMessage_CatalogSnapshot& operator=(const Message_ProductMessage_CatalogSnapshot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ProductMessage_CatalogSnapshot& operator=(Message_ProductMessage_CatalogSnapshot&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ProductMessage_CatalogSnapshot& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ProductMessage_CatalogSnapshot* internal_default_instance() {
+    return reinterpret_cast<const Message_ProductMessage_CatalogSnapshot*>(
+               &_Message_ProductMessage_CatalogSnapshot_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    118;
+
+  friend void swap(Message_ProductMessage_CatalogSnapshot& a, Message_ProductMessage_CatalogSnapshot& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ProductMessage_CatalogSnapshot* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ProductMessage_CatalogSnapshot* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ProductMessage_CatalogSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ProductMessage_CatalogSnapshot>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ProductMessage_CatalogSnapshot& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ProductMessage_CatalogSnapshot& from) {
+    Message_ProductMessage_CatalogSnapshot::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ProductMessage_CatalogSnapshot* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ProductMessage.CatalogSnapshot";
+  }
+  protected:
+  explicit Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTitleFieldNumber = 2,
+    kDescriptionFieldNumber = 3,
+    kCatalogImageFieldNumber = 1,
+  };
+  // optional string title = 2;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 3;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional .proto.Message.ImageMessage catalogImage = 1;
+  bool has_catalogimage() const;
+  private:
+  bool _internal_has_catalogimage() const;
+  public:
+  void clear_catalogimage();
+  const ::proto::Message_ImageMessage& catalogimage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_catalogimage();
+  ::proto::Message_ImageMessage* mutable_catalogimage();
+  void set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_catalogimage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_catalogimage();
+  public:
+  void unsafe_arena_set_allocated_catalogimage(
+      ::proto::Message_ImageMessage* catalogimage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_catalogimage();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.CatalogSnapshot)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::proto::Message_ImageMessage* catalogimage_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ProductMessage_ProductSnapshot final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.ProductSnapshot) */ {
+ public:
+  inline Message_ProductMessage_ProductSnapshot() : Message_ProductMessage_ProductSnapshot(nullptr) {}
+  ~Message_ProductMessage_ProductSnapshot() override;
+  explicit PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from);
+  Message_ProductMessage_ProductSnapshot(Message_ProductMessage_ProductSnapshot&& from) noexcept
+    : Message_ProductMessage_ProductSnapshot() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ProductMessage_ProductSnapshot& operator=(const Message_ProductMessage_ProductSnapshot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ProductMessage_ProductSnapshot& operator=(Message_ProductMessage_ProductSnapshot&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ProductMessage_ProductSnapshot& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ProductMessage_ProductSnapshot* internal_default_instance() {
+    return reinterpret_cast<const Message_ProductMessage_ProductSnapshot*>(
+               &_Message_ProductMessage_ProductSnapshot_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    119;
+
+  friend void swap(Message_ProductMessage_ProductSnapshot& a, Message_ProductMessage_ProductSnapshot& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ProductMessage_ProductSnapshot* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ProductMessage_ProductSnapshot* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ProductMessage_ProductSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ProductMessage_ProductSnapshot>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ProductMessage_ProductSnapshot& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ProductMessage_ProductSnapshot& from) {
+    Message_ProductMessage_ProductSnapshot::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ProductMessage_ProductSnapshot* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ProductMessage.ProductSnapshot";
+  }
+  protected:
+  explicit Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductIdFieldNumber = 2,
+    kTitleFieldNumber = 3,
+    kDescriptionFieldNumber = 4,
+    kCurrencyCodeFieldNumber = 5,
+    kRetailerIdFieldNumber = 7,
+    kUrlFieldNumber = 8,
+    kFirstImageIdFieldNumber = 11,
+    kProductImageFieldNumber = 1,
+    kPriceAmount1000FieldNumber = 6,
+    kSalePriceAmount1000FieldNumber = 12,
+    kProductImageCountFieldNumber = 9,
+  };
+  // optional string productId = 2;
+  bool has_productid() const;
+  private:
+  bool _internal_has_productid() const;
+  public:
+  void clear_productid();
+  const std::string& productid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_productid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_productid();
+  PROTOBUF_NODISCARD std::string* release_productid();
+  void set_allocated_productid(std::string* productid);
+  private:
+  const std::string& _internal_productid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
+  std::string* _internal_mutable_productid();
+  public:
+
+  // optional string title = 3;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 4;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string currencyCode = 5;
+  bool has_currencycode() const;
+  private:
+  bool _internal_has_currencycode() const;
+  public:
+  void clear_currencycode();
+  const std::string& currencycode() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_currencycode(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_currencycode();
+  PROTOBUF_NODISCARD std::string* release_currencycode();
+  void set_allocated_currencycode(std::string* currencycode);
+  private:
+  const std::string& _internal_currencycode() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
+  std::string* _internal_mutable_currencycode();
+  public:
+
+  // optional string retailerId = 7;
+  bool has_retailerid() const;
+  private:
+  bool _internal_has_retailerid() const;
+  public:
+  void clear_retailerid();
+  const std::string& retailerid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_retailerid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_retailerid();
+  PROTOBUF_NODISCARD std::string* release_retailerid();
+  void set_allocated_retailerid(std::string* retailerid);
+  private:
+  const std::string& _internal_retailerid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_retailerid(const std::string& value);
+  std::string* _internal_mutable_retailerid();
+  public:
+
+  // optional string url = 8;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string firstImageId = 11;
+  bool has_firstimageid() const;
+  private:
+  bool _internal_has_firstimageid() const;
+  public:
+  void clear_firstimageid();
+  const std::string& firstimageid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_firstimageid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_firstimageid();
+  PROTOBUF_NODISCARD std::string* release_firstimageid();
+  void set_allocated_firstimageid(std::string* firstimageid);
+  private:
+  const std::string& _internal_firstimageid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstimageid(const std::string& value);
+  std::string* _internal_mutable_firstimageid();
+  public:
+
+  // optional .proto.Message.ImageMessage productImage = 1;
+  bool has_productimage() const;
+  private:
+  bool _internal_has_productimage() const;
+  public:
+  void clear_productimage();
+  const ::proto::Message_ImageMessage& productimage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_productimage();
+  ::proto::Message_ImageMessage* mutable_productimage();
+  void set_allocated_productimage(::proto::Message_ImageMessage* productimage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_productimage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_productimage();
+  public:
+  void unsafe_arena_set_allocated_productimage(
+      ::proto::Message_ImageMessage* productimage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_productimage();
+
+  // optional int64 priceAmount1000 = 6;
+  bool has_priceamount1000() const;
+  private:
+  bool _internal_has_priceamount1000() const;
+  public:
+  void clear_priceamount1000();
+  int64_t priceamount1000() const;
+  void set_priceamount1000(int64_t value);
+  private:
+  int64_t _internal_priceamount1000() const;
+  void _internal_set_priceamount1000(int64_t value);
+  public:
+
+  // optional int64 salePriceAmount1000 = 12;
+  bool has_salepriceamount1000() const;
+  private:
+  bool _internal_has_salepriceamount1000() const;
+  public:
+  void clear_salepriceamount1000();
+  int64_t salepriceamount1000() const;
+  void set_salepriceamount1000(int64_t value);
+  private:
+  int64_t _internal_salepriceamount1000() const;
+  void _internal_set_salepriceamount1000(int64_t value);
+  public:
+
+  // optional uint32 productImageCount = 9;
+  bool has_productimagecount() const;
+  private:
+  bool _internal_has_productimagecount() const;
+  public:
+  void clear_productimagecount();
+  uint32_t productimagecount() const;
+  void set_productimagecount(uint32_t value);
+  private:
+  uint32_t _internal_productimagecount() const;
+  void _internal_set_productimagecount(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.ProductSnapshot)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retailerid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstimageid_;
+    ::proto::Message_ImageMessage* productimage_;
+    int64_t priceamount1000_;
+    int64_t salepriceamount1000_;
+    uint32_t productimagecount_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ProductMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage) */ {
+ public:
+  inline Message_ProductMessage() : Message_ProductMessage(nullptr) {}
+  ~Message_ProductMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ProductMessage(const Message_ProductMessage& from);
+  Message_ProductMessage(Message_ProductMessage&& from) noexcept
+    : Message_ProductMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ProductMessage& operator=(const Message_ProductMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ProductMessage& operator=(Message_ProductMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ProductMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ProductMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ProductMessage*>(
+               &_Message_ProductMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    120;
+
+  friend void swap(Message_ProductMessage& a, Message_ProductMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ProductMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ProductMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ProductMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ProductMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ProductMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ProductMessage& from) {
+    Message_ProductMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ProductMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ProductMessage";
+  }
+  protected:
+  explicit Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ProductMessage_CatalogSnapshot CatalogSnapshot;
+  typedef Message_ProductMessage_ProductSnapshot ProductSnapshot;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBusinessOwnerJidFieldNumber = 2,
+    kBodyFieldNumber = 5,
+    kFooterFieldNumber = 6,
+    kProductFieldNumber = 1,
+    kCatalogFieldNumber = 4,
+    kContextInfoFieldNumber = 17,
+  };
+  // optional string businessOwnerJid = 2;
+  bool has_businessownerjid() const;
+  private:
+  bool _internal_has_businessownerjid() const;
+  public:
+  void clear_businessownerjid();
+  const std::string& businessownerjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_businessownerjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_businessownerjid();
+  PROTOBUF_NODISCARD std::string* release_businessownerjid();
+  void set_allocated_businessownerjid(std::string* businessownerjid);
+  private:
+  const std::string& _internal_businessownerjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value);
+  std::string* _internal_mutable_businessownerjid();
+  public:
+
+  // optional string body = 5;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // optional string footer = 6;
+  bool has_footer() const;
+  private:
+  bool _internal_has_footer() const;
+  public:
+  void clear_footer();
+  const std::string& footer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_footer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_footer();
+  PROTOBUF_NODISCARD std::string* release_footer();
+  void set_allocated_footer(std::string* footer);
+  private:
+  const std::string& _internal_footer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footer(const std::string& value);
+  std::string* _internal_mutable_footer();
+  public:
+
+  // optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
+  bool has_product() const;
+  private:
+  bool _internal_has_product() const;
+  public:
+  void clear_product();
+  const ::proto::Message_ProductMessage_ProductSnapshot& product() const;
+  PROTOBUF_NODISCARD ::proto::Message_ProductMessage_ProductSnapshot* release_product();
+  ::proto::Message_ProductMessage_ProductSnapshot* mutable_product();
+  void set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product);
+  private:
+  const ::proto::Message_ProductMessage_ProductSnapshot& _internal_product() const;
+  ::proto::Message_ProductMessage_ProductSnapshot* _internal_mutable_product();
+  public:
+  void unsafe_arena_set_allocated_product(
+      ::proto::Message_ProductMessage_ProductSnapshot* product);
+  ::proto::Message_ProductMessage_ProductSnapshot* unsafe_arena_release_product();
+
+  // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
+  bool has_catalog() const;
+  private:
+  bool _internal_has_catalog() const;
+  public:
+  void clear_catalog();
+  const ::proto::Message_ProductMessage_CatalogSnapshot& catalog() const;
+  PROTOBUF_NODISCARD ::proto::Message_ProductMessage_CatalogSnapshot* release_catalog();
+  ::proto::Message_ProductMessage_CatalogSnapshot* mutable_catalog();
+  void set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog);
+  private:
+  const ::proto::Message_ProductMessage_CatalogSnapshot& _internal_catalog() const;
+  ::proto::Message_ProductMessage_CatalogSnapshot* _internal_mutable_catalog();
+  public:
+  void unsafe_arena_set_allocated_catalog(
+      ::proto::Message_ProductMessage_CatalogSnapshot* catalog);
+  ::proto::Message_ProductMessage_CatalogSnapshot* unsafe_arena_release_catalog();
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footer_;
+    ::proto::Message_ProductMessage_ProductSnapshot* product_;
+    ::proto::Message_ProductMessage_CatalogSnapshot* catalog_;
+    ::proto::ContextInfo* contextinfo_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ProtocolMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProtocolMessage) */ {
+ public:
+  inline Message_ProtocolMessage() : Message_ProtocolMessage(nullptr) {}
+  ~Message_ProtocolMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ProtocolMessage(const Message_ProtocolMessage& from);
+  Message_ProtocolMessage(Message_ProtocolMessage&& from) noexcept
+    : Message_ProtocolMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ProtocolMessage& operator=(const Message_ProtocolMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ProtocolMessage& operator=(Message_ProtocolMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ProtocolMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ProtocolMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ProtocolMessage*>(
+               &_Message_ProtocolMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    121;
+
+  friend void swap(Message_ProtocolMessage& a, Message_ProtocolMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ProtocolMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ProtocolMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ProtocolMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ProtocolMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ProtocolMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ProtocolMessage& from) {
+    Message_ProtocolMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ProtocolMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ProtocolMessage";
+  }
+  protected:
+  explicit Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_ProtocolMessage_Type Type;
+  static constexpr Type REVOKE =
+    Message_ProtocolMessage_Type_REVOKE;
+  static constexpr Type EPHEMERAL_SETTING =
+    Message_ProtocolMessage_Type_EPHEMERAL_SETTING;
+  static constexpr Type EPHEMERAL_SYNC_RESPONSE =
+    Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE;
+  static constexpr Type HISTORY_SYNC_NOTIFICATION =
+    Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION;
+  static constexpr Type APP_STATE_SYNC_KEY_SHARE =
+    Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE;
+  static constexpr Type APP_STATE_SYNC_KEY_REQUEST =
+    Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST;
+  static constexpr Type MSG_FANOUT_BACKFILL_REQUEST =
+    Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST;
+  static constexpr Type INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC =
+    Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC;
+  static constexpr Type APP_STATE_FATAL_EXCEPTION_NOTIFICATION =
+    Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION;
+  static constexpr Type SHARE_PHONE_NUMBER =
+    Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER;
+  static constexpr Type REQUEST_MEDIA_UPLOAD_MESSAGE =
+    Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE;
+  static constexpr Type REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE =
+    Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE;
+  static inline bool Type_IsValid(int value) {
+    return Message_ProtocolMessage_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    Message_ProtocolMessage_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    Message_ProtocolMessage_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    Message_ProtocolMessage_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return Message_ProtocolMessage_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return Message_ProtocolMessage_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return Message_ProtocolMessage_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kHistorySyncNotificationFieldNumber = 6,
+    kAppStateSyncKeyShareFieldNumber = 7,
+    kAppStateSyncKeyRequestFieldNumber = 8,
+    kInitialSecurityNotificationSettingSyncFieldNumber = 9,
+    kAppStateFatalExceptionNotificationFieldNumber = 10,
+    kDisappearingModeFieldNumber = 11,
+    kRequestMediaUploadMessageFieldNumber = 12,
+    kRequestMediaUploadResponseMessageFieldNumber = 13,
+    kTypeFieldNumber = 2,
+    kEphemeralExpirationFieldNumber = 4,
+    kEphemeralSettingTimestampFieldNumber = 5,
+  };
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
+  bool has_historysyncnotification() const;
+  private:
+  bool _internal_has_historysyncnotification() const;
+  public:
+  void clear_historysyncnotification();
+  const ::proto::Message_HistorySyncNotification& historysyncnotification() const;
+  PROTOBUF_NODISCARD ::proto::Message_HistorySyncNotification* release_historysyncnotification();
+  ::proto::Message_HistorySyncNotification* mutable_historysyncnotification();
+  void set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification);
+  private:
+  const ::proto::Message_HistorySyncNotification& _internal_historysyncnotification() const;
+  ::proto::Message_HistorySyncNotification* _internal_mutable_historysyncnotification();
+  public:
+  void unsafe_arena_set_allocated_historysyncnotification(
+      ::proto::Message_HistorySyncNotification* historysyncnotification);
+  ::proto::Message_HistorySyncNotification* unsafe_arena_release_historysyncnotification();
+
+  // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+  bool has_appstatesynckeyshare() const;
+  private:
+  bool _internal_has_appstatesynckeyshare() const;
+  public:
+  void clear_appstatesynckeyshare();
+  const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyShare* release_appstatesynckeyshare();
+  ::proto::Message_AppStateSyncKeyShare* mutable_appstatesynckeyshare();
+  void set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare);
+  private:
+  const ::proto::Message_AppStateSyncKeyShare& _internal_appstatesynckeyshare() const;
+  ::proto::Message_AppStateSyncKeyShare* _internal_mutable_appstatesynckeyshare();
+  public:
+  void unsafe_arena_set_allocated_appstatesynckeyshare(
+      ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare);
+  ::proto::Message_AppStateSyncKeyShare* unsafe_arena_release_appstatesynckeyshare();
+
+  // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+  bool has_appstatesynckeyrequest() const;
+  private:
+  bool _internal_has_appstatesynckeyrequest() const;
+  public:
+  void clear_appstatesynckeyrequest();
+  const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyRequest* release_appstatesynckeyrequest();
+  ::proto::Message_AppStateSyncKeyRequest* mutable_appstatesynckeyrequest();
+  void set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest);
+  private:
+  const ::proto::Message_AppStateSyncKeyRequest& _internal_appstatesynckeyrequest() const;
+  ::proto::Message_AppStateSyncKeyRequest* _internal_mutable_appstatesynckeyrequest();
+  public:
+  void unsafe_arena_set_allocated_appstatesynckeyrequest(
+      ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest);
+  ::proto::Message_AppStateSyncKeyRequest* unsafe_arena_release_appstatesynckeyrequest();
+
+  // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+  bool has_initialsecuritynotificationsettingsync() const;
+  private:
+  bool _internal_has_initialsecuritynotificationsettingsync() const;
+  public:
+  void clear_initialsecuritynotificationsettingsync();
+  const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync() const;
+  PROTOBUF_NODISCARD ::proto::Message_InitialSecurityNotificationSettingSync* release_initialsecuritynotificationsettingsync();
+  ::proto::Message_InitialSecurityNotificationSettingSync* mutable_initialsecuritynotificationsettingsync();
+  void set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync);
+  private:
+  const ::proto::Message_InitialSecurityNotificationSettingSync& _internal_initialsecuritynotificationsettingsync() const;
+  ::proto::Message_InitialSecurityNotificationSettingSync* _internal_mutable_initialsecuritynotificationsettingsync();
+  public:
+  void unsafe_arena_set_allocated_initialsecuritynotificationsettingsync(
+      ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync);
+  ::proto::Message_InitialSecurityNotificationSettingSync* unsafe_arena_release_initialsecuritynotificationsettingsync();
+
+  // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+  bool has_appstatefatalexceptionnotification() const;
+  private:
+  bool _internal_has_appstatefatalexceptionnotification() const;
+  public:
+  void clear_appstatefatalexceptionnotification();
+  const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification() const;
+  PROTOBUF_NODISCARD ::proto::Message_AppStateFatalExceptionNotification* release_appstatefatalexceptionnotification();
+  ::proto::Message_AppStateFatalExceptionNotification* mutable_appstatefatalexceptionnotification();
+  void set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification);
+  private:
+  const ::proto::Message_AppStateFatalExceptionNotification& _internal_appstatefatalexceptionnotification() const;
+  ::proto::Message_AppStateFatalExceptionNotification* _internal_mutable_appstatefatalexceptionnotification();
+  public:
+  void unsafe_arena_set_allocated_appstatefatalexceptionnotification(
+      ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification);
+  ::proto::Message_AppStateFatalExceptionNotification* unsafe_arena_release_appstatefatalexceptionnotification();
+
+  // optional .proto.DisappearingMode disappearingMode = 11;
+  bool has_disappearingmode() const;
+  private:
+  bool _internal_has_disappearingmode() const;
+  public:
+  void clear_disappearingmode();
+  const ::proto::DisappearingMode& disappearingmode() const;
+  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
+  ::proto::DisappearingMode* mutable_disappearingmode();
+  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
+  private:
+  const ::proto::DisappearingMode& _internal_disappearingmode() const;
+  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
+  public:
+  void unsafe_arena_set_allocated_disappearingmode(
+      ::proto::DisappearingMode* disappearingmode);
+  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();
+
+  // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+  bool has_requestmediauploadmessage() const;
+  private:
+  bool _internal_has_requestmediauploadmessage() const;
+  public:
+  void clear_requestmediauploadmessage();
+  const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadMessage* release_requestmediauploadmessage();
+  ::proto::Message_RequestMediaUploadMessage* mutable_requestmediauploadmessage();
+  void set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage);
+  private:
+  const ::proto::Message_RequestMediaUploadMessage& _internal_requestmediauploadmessage() const;
+  ::proto::Message_RequestMediaUploadMessage* _internal_mutable_requestmediauploadmessage();
+  public:
+  void unsafe_arena_set_allocated_requestmediauploadmessage(
+      ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage);
+  ::proto::Message_RequestMediaUploadMessage* unsafe_arena_release_requestmediauploadmessage();
+
+  // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+  bool has_requestmediauploadresponsemessage() const;
+  private:
+  bool _internal_has_requestmediauploadresponsemessage() const;
+  public:
+  void clear_requestmediauploadresponsemessage();
+  const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadResponseMessage* release_requestmediauploadresponsemessage();
+  ::proto::Message_RequestMediaUploadResponseMessage* mutable_requestmediauploadresponsemessage();
+  void set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage);
+  private:
+  const ::proto::Message_RequestMediaUploadResponseMessage& _internal_requestmediauploadresponsemessage() const;
+  ::proto::Message_RequestMediaUploadResponseMessage* _internal_mutable_requestmediauploadresponsemessage();
+  public:
+  void unsafe_arena_set_allocated_requestmediauploadresponsemessage(
+      ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage);
+  ::proto::Message_RequestMediaUploadResponseMessage* unsafe_arena_release_requestmediauploadresponsemessage();
+
+  // optional .proto.Message.ProtocolMessage.Type type = 2;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::proto::Message_ProtocolMessage_Type type() const;
+  void set_type(::proto::Message_ProtocolMessage_Type value);
+  private:
+  ::proto::Message_ProtocolMessage_Type _internal_type() const;
+  void _internal_set_type(::proto::Message_ProtocolMessage_Type value);
+  public:
+
+  // optional uint32 ephemeralExpiration = 4;
+  bool has_ephemeralexpiration() const;
+  private:
+  bool _internal_has_ephemeralexpiration() const;
+  public:
+  void clear_ephemeralexpiration();
+  uint32_t ephemeralexpiration() const;
+  void set_ephemeralexpiration(uint32_t value);
+  private:
+  uint32_t _internal_ephemeralexpiration() const;
+  void _internal_set_ephemeralexpiration(uint32_t value);
+  public:
+
+  // optional int64 ephemeralSettingTimestamp = 5;
+  bool has_ephemeralsettingtimestamp() const;
+  private:
+  bool _internal_has_ephemeralsettingtimestamp() const;
+  public:
+  void clear_ephemeralsettingtimestamp();
+  int64_t ephemeralsettingtimestamp() const;
+  void set_ephemeralsettingtimestamp(int64_t value);
+  private:
+  int64_t _internal_ephemeralsettingtimestamp() const;
+  void _internal_set_ephemeralsettingtimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ProtocolMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* key_;
+    ::proto::Message_HistorySyncNotification* historysyncnotification_;
+    ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare_;
+    ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest_;
+    ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync_;
+    ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification_;
+    ::proto::DisappearingMode* disappearingmode_;
+    ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage_;
+    ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage_;
+    int type_;
+    uint32_t ephemeralexpiration_;
+    int64_t ephemeralsettingtimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_ReactionMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ReactionMessage) */ {
+ public:
+  inline Message_ReactionMessage() : Message_ReactionMessage(nullptr) {}
+  ~Message_ReactionMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_ReactionMessage(const Message_ReactionMessage& from);
+  Message_ReactionMessage(Message_ReactionMessage&& from) noexcept
+    : Message_ReactionMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_ReactionMessage& operator=(const Message_ReactionMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_ReactionMessage& operator=(Message_ReactionMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_ReactionMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_ReactionMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_ReactionMessage*>(
+               &_Message_ReactionMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    122;
+
+  friend void swap(Message_ReactionMessage& a, Message_ReactionMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_ReactionMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_ReactionMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_ReactionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_ReactionMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_ReactionMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_ReactionMessage& from) {
+    Message_ReactionMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_ReactionMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.ReactionMessage";
+  }
+  protected:
+  explicit Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 2,
+    kGroupingKeyFieldNumber = 3,
+    kKeyFieldNumber = 1,
+    kSenderTimestampMsFieldNumber = 4,
+  };
+  // optional string text = 2;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // optional string groupingKey = 3;
+  bool has_groupingkey() const;
+  private:
+  bool _internal_has_groupingkey() const;
+  public:
+  void clear_groupingkey();
+  const std::string& groupingkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupingkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupingkey();
+  PROTOBUF_NODISCARD std::string* release_groupingkey();
+  void set_allocated_groupingkey(std::string* groupingkey);
+  private:
+  const std::string& _internal_groupingkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value);
+  std::string* _internal_mutable_groupingkey();
+  public:
+
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional int64 senderTimestampMs = 4;
+  bool has_sendertimestampms() const;
+  private:
+  bool _internal_has_sendertimestampms() const;
+  public:
+  void clear_sendertimestampms();
+  int64_t sendertimestampms() const;
+  void set_sendertimestampms(int64_t value);
+  private:
+  int64_t _internal_sendertimestampms() const;
+  void _internal_set_sendertimestampms(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.ReactionMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_;
+    ::proto::MessageKey* key_;
+    int64_t sendertimestampms_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_RequestMediaUploadMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadMessage) */ {
+ public:
+  inline Message_RequestMediaUploadMessage() : Message_RequestMediaUploadMessage(nullptr) {}
+  ~Message_RequestMediaUploadMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from);
+  Message_RequestMediaUploadMessage(Message_RequestMediaUploadMessage&& from) noexcept
+    : Message_RequestMediaUploadMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_RequestMediaUploadMessage& operator=(const Message_RequestMediaUploadMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_RequestMediaUploadMessage& operator=(Message_RequestMediaUploadMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_RequestMediaUploadMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_RequestMediaUploadMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_RequestMediaUploadMessage*>(
+               &_Message_RequestMediaUploadMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    123;
+
+  friend void swap(Message_RequestMediaUploadMessage& a, Message_RequestMediaUploadMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_RequestMediaUploadMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_RequestMediaUploadMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_RequestMediaUploadMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_RequestMediaUploadMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_RequestMediaUploadMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_RequestMediaUploadMessage& from) {
+    Message_RequestMediaUploadMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_RequestMediaUploadMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.RequestMediaUploadMessage";
+  }
+  protected:
+  explicit Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileSha256FieldNumber = 1,
+    kRmrSourceFieldNumber = 2,
+  };
+  // repeated string fileSha256 = 1;
+  int filesha256_size() const;
+  private:
+  int _internal_filesha256_size() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256(int index) const;
+  std::string* mutable_filesha256(int index);
+  void set_filesha256(int index, const std::string& value);
+  void set_filesha256(int index, std::string&& value);
+  void set_filesha256(int index, const char* value);
+  void set_filesha256(int index, const char* value, size_t size);
+  std::string* add_filesha256();
+  void add_filesha256(const std::string& value);
+  void add_filesha256(std::string&& value);
+  void add_filesha256(const char* value);
+  void add_filesha256(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& filesha256() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_filesha256();
+  private:
+  const std::string& _internal_filesha256(int index) const;
+  std::string* _internal_add_filesha256();
+  public:
+
+  // optional .proto.Message.RmrSource rmrSource = 2;
+  bool has_rmrsource() const;
+  private:
+  bool _internal_has_rmrsource() const;
+  public:
+  void clear_rmrsource();
+  ::proto::Message_RmrSource rmrsource() const;
+  void set_rmrsource(::proto::Message_RmrSource value);
+  private:
+  ::proto::Message_RmrSource _internal_rmrsource() const;
+  void _internal_set_rmrsource(::proto::Message_RmrSource value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> filesha256_;
+    int rmrsource_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) */ {
+ public:
+  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(nullptr) {}
+  ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() override;
+  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from);
+  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept
+    : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* internal_default_instance() {
+    return reinterpret_cast<const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult*>(
+               &_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    124;
+
+  friend void swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& a, Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) {
+    Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult";
+  }
+  protected:
+  explicit Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileSha256FieldNumber = 1,
+    kStickerMessageFieldNumber = 3,
+    kMediaUploadResultFieldNumber = 2,
+  };
+  // optional string fileSha256 = 1;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional .proto.Message.StickerMessage stickerMessage = 3;
+  bool has_stickermessage() const;
+  private:
+  bool _internal_has_stickermessage() const;
+  public:
+  void clear_stickermessage();
+  const ::proto::Message_StickerMessage& stickermessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage();
+  ::proto::Message_StickerMessage* mutable_stickermessage();
+  void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage);
+  private:
+  const ::proto::Message_StickerMessage& _internal_stickermessage() const;
+  ::proto::Message_StickerMessage* _internal_mutable_stickermessage();
+  public:
+  void unsafe_arena_set_allocated_stickermessage(
+      ::proto::Message_StickerMessage* stickermessage);
+  ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage();
+
+  // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
+  bool has_mediauploadresult() const;
+  private:
+  bool _internal_has_mediauploadresult() const;
+  public:
+  void clear_mediauploadresult();
+  ::proto::MediaRetryNotification_ResultType mediauploadresult() const;
+  void set_mediauploadresult(::proto::MediaRetryNotification_ResultType value);
+  private:
+  ::proto::MediaRetryNotification_ResultType _internal_mediauploadresult() const;
+  void _internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::proto::Message_StickerMessage* stickermessage_;
+    int mediauploadresult_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_RequestMediaUploadResponseMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage) */ {
+ public:
+  inline Message_RequestMediaUploadResponseMessage() : Message_RequestMediaUploadResponseMessage(nullptr) {}
+  ~Message_RequestMediaUploadResponseMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from);
+  Message_RequestMediaUploadResponseMessage(Message_RequestMediaUploadResponseMessage&& from) noexcept
+    : Message_RequestMediaUploadResponseMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_RequestMediaUploadResponseMessage& operator=(const Message_RequestMediaUploadResponseMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_RequestMediaUploadResponseMessage& operator=(Message_RequestMediaUploadResponseMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_RequestMediaUploadResponseMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_RequestMediaUploadResponseMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_RequestMediaUploadResponseMessage*>(
+               &_Message_RequestMediaUploadResponseMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    125;
+
+  friend void swap(Message_RequestMediaUploadResponseMessage& a, Message_RequestMediaUploadResponseMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_RequestMediaUploadResponseMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_RequestMediaUploadResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_RequestMediaUploadResponseMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_RequestMediaUploadResponseMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_RequestMediaUploadResponseMessage& from) {
+    Message_RequestMediaUploadResponseMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_RequestMediaUploadResponseMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.RequestMediaUploadResponseMessage";
+  }
+  protected:
+  explicit Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult RequestMediaUploadResult;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReuploadResultFieldNumber = 3,
+    kStanzaIdFieldNumber = 2,
+    kRmrSourceFieldNumber = 1,
+  };
+  // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
+  int reuploadresult_size() const;
+  private:
+  int _internal_reuploadresult_size() const;
+  public:
+  void clear_reuploadresult();
+  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* mutable_reuploadresult(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >*
+      mutable_reuploadresult();
+  private:
+  const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& _internal_reuploadresult(int index) const;
+  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _internal_add_reuploadresult();
+  public:
+  const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& reuploadresult(int index) const;
+  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* add_reuploadresult();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >&
+      reuploadresult() const;
+
+  // optional string stanzaId = 2;
+  bool has_stanzaid() const;
+  private:
+  bool _internal_has_stanzaid() const;
+  public:
+  void clear_stanzaid();
+  const std::string& stanzaid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stanzaid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stanzaid();
+  PROTOBUF_NODISCARD std::string* release_stanzaid();
+  void set_allocated_stanzaid(std::string* stanzaid);
+  private:
+  const std::string& _internal_stanzaid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
+  std::string* _internal_mutable_stanzaid();
+  public:
+
+  // optional .proto.Message.RmrSource rmrSource = 1;
+  bool has_rmrsource() const;
+  private:
+  bool _internal_has_rmrsource() const;
+  public:
+  void clear_rmrsource();
+  ::proto::Message_RmrSource rmrsource() const;
+  void set_rmrsource(::proto::Message_RmrSource value);
+  private:
+  ::proto::Message_RmrSource _internal_rmrsource() const;
+  void _internal_set_rmrsource(::proto::Message_RmrSource value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult > reuploadresult_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
+    int rmrsource_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_RequestPaymentMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPaymentMessage) */ {
+ public:
+  inline Message_RequestPaymentMessage() : Message_RequestPaymentMessage(nullptr) {}
+  ~Message_RequestPaymentMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from);
+  Message_RequestPaymentMessage(Message_RequestPaymentMessage&& from) noexcept
+    : Message_RequestPaymentMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_RequestPaymentMessage& operator=(const Message_RequestPaymentMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_RequestPaymentMessage& operator=(Message_RequestPaymentMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_RequestPaymentMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_RequestPaymentMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_RequestPaymentMessage*>(
+               &_Message_RequestPaymentMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    126;
+
+  friend void swap(Message_RequestPaymentMessage& a, Message_RequestPaymentMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_RequestPaymentMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_RequestPaymentMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_RequestPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_RequestPaymentMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_RequestPaymentMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_RequestPaymentMessage& from) {
+    Message_RequestPaymentMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_RequestPaymentMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.RequestPaymentMessage";
+  }
+  protected:
+  explicit Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCurrencyCodeIso4217FieldNumber = 1,
+    kRequestFromFieldNumber = 3,
+    kNoteMessageFieldNumber = 4,
+    kAmountFieldNumber = 6,
+    kBackgroundFieldNumber = 7,
+    kAmount1000FieldNumber = 2,
+    kExpiryTimestampFieldNumber = 5,
+  };
+  // optional string currencyCodeIso4217 = 1;
+  bool has_currencycodeiso4217() const;
+  private:
+  bool _internal_has_currencycodeiso4217() const;
+  public:
+  void clear_currencycodeiso4217();
+  const std::string& currencycodeiso4217() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_currencycodeiso4217(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_currencycodeiso4217();
+  PROTOBUF_NODISCARD std::string* release_currencycodeiso4217();
+  void set_allocated_currencycodeiso4217(std::string* currencycodeiso4217);
+  private:
+  const std::string& _internal_currencycodeiso4217() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycodeiso4217(const std::string& value);
+  std::string* _internal_mutable_currencycodeiso4217();
+  public:
+
+  // optional string requestFrom = 3;
+  bool has_requestfrom() const;
+  private:
+  bool _internal_has_requestfrom() const;
+  public:
+  void clear_requestfrom();
+  const std::string& requestfrom() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_requestfrom(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_requestfrom();
+  PROTOBUF_NODISCARD std::string* release_requestfrom();
+  void set_allocated_requestfrom(std::string* requestfrom);
+  private:
+  const std::string& _internal_requestfrom() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestfrom(const std::string& value);
+  std::string* _internal_mutable_requestfrom();
+  public:
+
+  // optional .proto.Message noteMessage = 4;
+  bool has_notemessage() const;
+  private:
+  bool _internal_has_notemessage() const;
+  public:
+  void clear_notemessage();
+  const ::proto::Message& notemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_notemessage();
+  ::proto::Message* mutable_notemessage();
+  void set_allocated_notemessage(::proto::Message* notemessage);
+  private:
+  const ::proto::Message& _internal_notemessage() const;
+  ::proto::Message* _internal_mutable_notemessage();
+  public:
+  void unsafe_arena_set_allocated_notemessage(
+      ::proto::Message* notemessage);
+  ::proto::Message* unsafe_arena_release_notemessage();
+
+  // optional .proto.Money amount = 6;
+  bool has_amount() const;
+  private:
+  bool _internal_has_amount() const;
+  public:
+  void clear_amount();
+  const ::proto::Money& amount() const;
+  PROTOBUF_NODISCARD ::proto::Money* release_amount();
+  ::proto::Money* mutable_amount();
+  void set_allocated_amount(::proto::Money* amount);
+  private:
+  const ::proto::Money& _internal_amount() const;
+  ::proto::Money* _internal_mutable_amount();
+  public:
+  void unsafe_arena_set_allocated_amount(
+      ::proto::Money* amount);
+  ::proto::Money* unsafe_arena_release_amount();
+
+  // optional .proto.PaymentBackground background = 7;
+  bool has_background() const;
+  private:
+  bool _internal_has_background() const;
+  public:
+  void clear_background();
+  const ::proto::PaymentBackground& background() const;
+  PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background();
+  ::proto::PaymentBackground* mutable_background();
+  void set_allocated_background(::proto::PaymentBackground* background);
+  private:
+  const ::proto::PaymentBackground& _internal_background() const;
+  ::proto::PaymentBackground* _internal_mutable_background();
+  public:
+  void unsafe_arena_set_allocated_background(
+      ::proto::PaymentBackground* background);
+  ::proto::PaymentBackground* unsafe_arena_release_background();
+
+  // optional uint64 amount1000 = 2;
+  bool has_amount1000() const;
+  private:
+  bool _internal_has_amount1000() const;
+  public:
+  void clear_amount1000();
+  uint64_t amount1000() const;
+  void set_amount1000(uint64_t value);
+  private:
+  uint64_t _internal_amount1000() const;
+  void _internal_set_amount1000(uint64_t value);
+  public:
+
+  // optional int64 expiryTimestamp = 5;
+  bool has_expirytimestamp() const;
+  private:
+  bool _internal_has_expirytimestamp() const;
+  public:
+  void clear_expirytimestamp();
+  int64_t expirytimestamp() const;
+  void set_expirytimestamp(int64_t value);
+  private:
+  int64_t _internal_expirytimestamp() const;
+  void _internal_set_expirytimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.RequestPaymentMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycodeiso4217_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestfrom_;
+    ::proto::Message* notemessage_;
+    ::proto::Money* amount_;
+    ::proto::PaymentBackground* background_;
+    uint64_t amount1000_;
+    int64_t expirytimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_RequestPhoneNumberMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPhoneNumberMessage) */ {
+ public:
+  inline Message_RequestPhoneNumberMessage() : Message_RequestPhoneNumberMessage(nullptr) {}
+  ~Message_RequestPhoneNumberMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from);
+  Message_RequestPhoneNumberMessage(Message_RequestPhoneNumberMessage&& from) noexcept
+    : Message_RequestPhoneNumberMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_RequestPhoneNumberMessage& operator=(const Message_RequestPhoneNumberMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_RequestPhoneNumberMessage& operator=(Message_RequestPhoneNumberMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_RequestPhoneNumberMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_RequestPhoneNumberMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_RequestPhoneNumberMessage*>(
+               &_Message_RequestPhoneNumberMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    127;
+
+  friend void swap(Message_RequestPhoneNumberMessage& a, Message_RequestPhoneNumberMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_RequestPhoneNumberMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_RequestPhoneNumberMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_RequestPhoneNumberMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_RequestPhoneNumberMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_RequestPhoneNumberMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_RequestPhoneNumberMessage& from) {
+    Message_RequestPhoneNumberMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_RequestPhoneNumberMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.RequestPhoneNumberMessage";
+  }
+  protected:
+  explicit Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContextInfoFieldNumber = 1,
+  };
+  // optional .proto.ContextInfo contextInfo = 1;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.RequestPhoneNumberMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::ContextInfo* contextinfo_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_SendPaymentMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SendPaymentMessage) */ {
+ public:
+  inline Message_SendPaymentMessage() : Message_SendPaymentMessage(nullptr) {}
+  ~Message_SendPaymentMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_SendPaymentMessage(const Message_SendPaymentMessage& from);
+  Message_SendPaymentMessage(Message_SendPaymentMessage&& from) noexcept
+    : Message_SendPaymentMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_SendPaymentMessage& operator=(const Message_SendPaymentMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_SendPaymentMessage& operator=(Message_SendPaymentMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_SendPaymentMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_SendPaymentMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_SendPaymentMessage*>(
+               &_Message_SendPaymentMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    128;
+
+  friend void swap(Message_SendPaymentMessage& a, Message_SendPaymentMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_SendPaymentMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_SendPaymentMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_SendPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_SendPaymentMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_SendPaymentMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_SendPaymentMessage& from) {
+    Message_SendPaymentMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_SendPaymentMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.SendPaymentMessage";
+  }
+  protected:
+  explicit Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNoteMessageFieldNumber = 2,
+    kRequestMessageKeyFieldNumber = 3,
+    kBackgroundFieldNumber = 4,
+  };
+  // optional .proto.Message noteMessage = 2;
+  bool has_notemessage() const;
+  private:
+  bool _internal_has_notemessage() const;
+  public:
+  void clear_notemessage();
+  const ::proto::Message& notemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_notemessage();
+  ::proto::Message* mutable_notemessage();
+  void set_allocated_notemessage(::proto::Message* notemessage);
+  private:
+  const ::proto::Message& _internal_notemessage() const;
+  ::proto::Message* _internal_mutable_notemessage();
+  public:
+  void unsafe_arena_set_allocated_notemessage(
+      ::proto::Message* notemessage);
+  ::proto::Message* unsafe_arena_release_notemessage();
+
+  // optional .proto.MessageKey requestMessageKey = 3;
+  bool has_requestmessagekey() const;
+  private:
+  bool _internal_has_requestmessagekey() const;
+  public:
+  void clear_requestmessagekey();
+  const ::proto::MessageKey& requestmessagekey() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey();
+  ::proto::MessageKey* mutable_requestmessagekey();
+  void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey);
+  private:
+  const ::proto::MessageKey& _internal_requestmessagekey() const;
+  ::proto::MessageKey* _internal_mutable_requestmessagekey();
+  public:
+  void unsafe_arena_set_allocated_requestmessagekey(
+      ::proto::MessageKey* requestmessagekey);
+  ::proto::MessageKey* unsafe_arena_release_requestmessagekey();
+
+  // optional .proto.PaymentBackground background = 4;
+  bool has_background() const;
+  private:
+  bool _internal_has_background() const;
+  public:
+  void clear_background();
+  const ::proto::PaymentBackground& background() const;
+  PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background();
+  ::proto::PaymentBackground* mutable_background();
+  void set_allocated_background(::proto::PaymentBackground* background);
+  private:
+  const ::proto::PaymentBackground& _internal_background() const;
+  ::proto::PaymentBackground* _internal_mutable_background();
+  public:
+  void unsafe_arena_set_allocated_background(
+      ::proto::PaymentBackground* background);
+  ::proto::PaymentBackground* unsafe_arena_release_background();
+
+  // @@protoc_insertion_point(class_scope:proto.Message.SendPaymentMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message* notemessage_;
+    ::proto::MessageKey* requestmessagekey_;
+    ::proto::PaymentBackground* background_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_SenderKeyDistributionMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SenderKeyDistributionMessage) */ {
+ public:
+  inline Message_SenderKeyDistributionMessage() : Message_SenderKeyDistributionMessage(nullptr) {}
+  ~Message_SenderKeyDistributionMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from);
+  Message_SenderKeyDistributionMessage(Message_SenderKeyDistributionMessage&& from) noexcept
+    : Message_SenderKeyDistributionMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_SenderKeyDistributionMessage& operator=(const Message_SenderKeyDistributionMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_SenderKeyDistributionMessage& operator=(Message_SenderKeyDistributionMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_SenderKeyDistributionMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_SenderKeyDistributionMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_SenderKeyDistributionMessage*>(
+               &_Message_SenderKeyDistributionMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    129;
+
+  friend void swap(Message_SenderKeyDistributionMessage& a, Message_SenderKeyDistributionMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_SenderKeyDistributionMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_SenderKeyDistributionMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_SenderKeyDistributionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_SenderKeyDistributionMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_SenderKeyDistributionMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_SenderKeyDistributionMessage& from) {
+    Message_SenderKeyDistributionMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_SenderKeyDistributionMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.SenderKeyDistributionMessage";
+  }
+  protected:
+  explicit Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupIdFieldNumber = 1,
+    kAxolotlSenderKeyDistributionMessageFieldNumber = 2,
+  };
+  // optional string groupId = 1;
+  bool has_groupid() const;
+  private:
+  bool _internal_has_groupid() const;
+  public:
+  void clear_groupid();
+  const std::string& groupid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupid();
+  PROTOBUF_NODISCARD std::string* release_groupid();
+  void set_allocated_groupid(std::string* groupid);
+  private:
+  const std::string& _internal_groupid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupid(const std::string& value);
+  std::string* _internal_mutable_groupid();
+  public:
+
+  // optional bytes axolotlSenderKeyDistributionMessage = 2;
+  bool has_axolotlsenderkeydistributionmessage() const;
+  private:
+  bool _internal_has_axolotlsenderkeydistributionmessage() const;
+  public:
+  void clear_axolotlsenderkeydistributionmessage();
+  const std::string& axolotlsenderkeydistributionmessage() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_axolotlsenderkeydistributionmessage();
+  PROTOBUF_NODISCARD std::string* release_axolotlsenderkeydistributionmessage();
+  void set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage);
+  private:
+  const std::string& _internal_axolotlsenderkeydistributionmessage() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_axolotlsenderkeydistributionmessage(const std::string& value);
+  std::string* _internal_mutable_axolotlsenderkeydistributionmessage();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.SenderKeyDistributionMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr axolotlsenderkeydistributionmessage_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_StickerMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerMessage) */ {
+ public:
+  inline Message_StickerMessage() : Message_StickerMessage(nullptr) {}
+  ~Message_StickerMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_StickerMessage(const Message_StickerMessage& from);
+  Message_StickerMessage(Message_StickerMessage&& from) noexcept
+    : Message_StickerMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_StickerMessage& operator=(const Message_StickerMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_StickerMessage& operator=(Message_StickerMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_StickerMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_StickerMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_StickerMessage*>(
+               &_Message_StickerMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    130;
+
+  friend void swap(Message_StickerMessage& a, Message_StickerMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_StickerMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_StickerMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_StickerMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_StickerMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_StickerMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_StickerMessage& from) {
+    Message_StickerMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_StickerMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.StickerMessage";
+  }
+  protected:
+  explicit Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kFileSha256FieldNumber = 2,
+    kFileEncSha256FieldNumber = 3,
+    kMediaKeyFieldNumber = 4,
+    kMimetypeFieldNumber = 5,
+    kDirectPathFieldNumber = 8,
+    kFirstFrameSidecarFieldNumber = 12,
+    kPngThumbnailFieldNumber = 16,
+    kContextInfoFieldNumber = 17,
+    kHeightFieldNumber = 6,
+    kWidthFieldNumber = 7,
+    kFileLengthFieldNumber = 9,
+    kMediaKeyTimestampFieldNumber = 10,
+    kFirstFrameLengthFieldNumber = 11,
+    kIsAnimatedFieldNumber = 13,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional bytes fileSha256 = 2;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes fileEncSha256 = 3;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional bytes mediaKey = 4;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string mimetype = 5;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional string directPath = 8;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional bytes firstFrameSidecar = 12;
+  bool has_firstframesidecar() const;
+  private:
+  bool _internal_has_firstframesidecar() const;
+  public:
+  void clear_firstframesidecar();
+  const std::string& firstframesidecar() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_firstframesidecar(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_firstframesidecar();
+  PROTOBUF_NODISCARD std::string* release_firstframesidecar();
+  void set_allocated_firstframesidecar(std::string* firstframesidecar);
+  private:
+  const std::string& _internal_firstframesidecar() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstframesidecar(const std::string& value);
+  std::string* _internal_mutable_firstframesidecar();
+  public:
+
+  // optional bytes pngThumbnail = 16;
+  bool has_pngthumbnail() const;
+  private:
+  bool _internal_has_pngthumbnail() const;
+  public:
+  void clear_pngthumbnail();
+  const std::string& pngthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pngthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pngthumbnail();
+  PROTOBUF_NODISCARD std::string* release_pngthumbnail();
+  void set_allocated_pngthumbnail(std::string* pngthumbnail);
+  private:
+  const std::string& _internal_pngthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pngthumbnail(const std::string& value);
+  std::string* _internal_mutable_pngthumbnail();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint32 height = 6;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional uint32 width = 7;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional uint64 fileLength = 9;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 10;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // optional uint32 firstFrameLength = 11;
+  bool has_firstframelength() const;
+  private:
+  bool _internal_has_firstframelength() const;
+  public:
+  void clear_firstframelength();
+  uint32_t firstframelength() const;
+  void set_firstframelength(uint32_t value);
+  private:
+  uint32_t _internal_firstframelength() const;
+  void _internal_set_firstframelength(uint32_t value);
+  public:
+
+  // optional bool isAnimated = 13;
+  bool has_isanimated() const;
+  private:
+  bool _internal_has_isanimated() const;
+  public:
+  void clear_isanimated();
+  bool isanimated() const;
+  void set_isanimated(bool value);
+  private:
+  bool _internal_isanimated() const;
+  void _internal_set_isanimated(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.StickerMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstframesidecar_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pngthumbnail_;
+    ::proto::ContextInfo* contextinfo_;
+    uint32_t height_;
+    uint32_t width_;
+    uint64_t filelength_;
+    int64_t mediakeytimestamp_;
+    uint32_t firstframelength_;
+    bool isanimated_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_StickerSyncRMRMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerSyncRMRMessage) */ {
+ public:
+  inline Message_StickerSyncRMRMessage() : Message_StickerSyncRMRMessage(nullptr) {}
+  ~Message_StickerSyncRMRMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from);
+  Message_StickerSyncRMRMessage(Message_StickerSyncRMRMessage&& from) noexcept
+    : Message_StickerSyncRMRMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_StickerSyncRMRMessage& operator=(const Message_StickerSyncRMRMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_StickerSyncRMRMessage& operator=(Message_StickerSyncRMRMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_StickerSyncRMRMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_StickerSyncRMRMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_StickerSyncRMRMessage*>(
+               &_Message_StickerSyncRMRMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    131;
+
+  friend void swap(Message_StickerSyncRMRMessage& a, Message_StickerSyncRMRMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_StickerSyncRMRMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_StickerSyncRMRMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_StickerSyncRMRMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_StickerSyncRMRMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_StickerSyncRMRMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_StickerSyncRMRMessage& from) {
+    Message_StickerSyncRMRMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_StickerSyncRMRMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.StickerSyncRMRMessage";
+  }
+  protected:
+  explicit Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFilehashFieldNumber = 1,
+    kRmrSourceFieldNumber = 2,
+    kRequestTimestampFieldNumber = 3,
+  };
+  // repeated string filehash = 1;
+  int filehash_size() const;
+  private:
+  int _internal_filehash_size() const;
+  public:
+  void clear_filehash();
+  const std::string& filehash(int index) const;
+  std::string* mutable_filehash(int index);
+  void set_filehash(int index, const std::string& value);
+  void set_filehash(int index, std::string&& value);
+  void set_filehash(int index, const char* value);
+  void set_filehash(int index, const char* value, size_t size);
+  std::string* add_filehash();
+  void add_filehash(const std::string& value);
+  void add_filehash(std::string&& value);
+  void add_filehash(const char* value);
+  void add_filehash(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& filehash() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_filehash();
+  private:
+  const std::string& _internal_filehash(int index) const;
+  std::string* _internal_add_filehash();
+  public:
+
+  // optional string rmrSource = 2;
+  bool has_rmrsource() const;
+  private:
+  bool _internal_has_rmrsource() const;
+  public:
+  void clear_rmrsource();
+  const std::string& rmrsource() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rmrsource(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rmrsource();
+  PROTOBUF_NODISCARD std::string* release_rmrsource();
+  void set_allocated_rmrsource(std::string* rmrsource);
+  private:
+  const std::string& _internal_rmrsource() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rmrsource(const std::string& value);
+  std::string* _internal_mutable_rmrsource();
+  public:
+
+  // optional int64 requestTimestamp = 3;
+  bool has_requesttimestamp() const;
+  private:
+  bool _internal_has_requesttimestamp() const;
+  public:
+  void clear_requesttimestamp();
+  int64_t requesttimestamp() const;
+  void set_requesttimestamp(int64_t value);
+  private:
+  int64_t _internal_requesttimestamp() const;
+  void _internal_set_requesttimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.StickerSyncRMRMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> filehash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rmrsource_;
+    int64_t requesttimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_TemplateButtonReplyMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateButtonReplyMessage) */ {
+ public:
+  inline Message_TemplateButtonReplyMessage() : Message_TemplateButtonReplyMessage(nullptr) {}
+  ~Message_TemplateButtonReplyMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from);
+  Message_TemplateButtonReplyMessage(Message_TemplateButtonReplyMessage&& from) noexcept
+    : Message_TemplateButtonReplyMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_TemplateButtonReplyMessage& operator=(const Message_TemplateButtonReplyMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_TemplateButtonReplyMessage& operator=(Message_TemplateButtonReplyMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_TemplateButtonReplyMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_TemplateButtonReplyMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_TemplateButtonReplyMessage*>(
+               &_Message_TemplateButtonReplyMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    132;
+
+  friend void swap(Message_TemplateButtonReplyMessage& a, Message_TemplateButtonReplyMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_TemplateButtonReplyMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_TemplateButtonReplyMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_TemplateButtonReplyMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_TemplateButtonReplyMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_TemplateButtonReplyMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_TemplateButtonReplyMessage& from) {
+    Message_TemplateButtonReplyMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_TemplateButtonReplyMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.TemplateButtonReplyMessage";
+  }
+  protected:
+  explicit Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectedIdFieldNumber = 1,
+    kSelectedDisplayTextFieldNumber = 2,
+    kContextInfoFieldNumber = 3,
+    kSelectedIndexFieldNumber = 4,
+  };
+  // optional string selectedId = 1;
+  bool has_selectedid() const;
+  private:
+  bool _internal_has_selectedid() const;
+  public:
+  void clear_selectedid();
+  const std::string& selectedid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_selectedid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_selectedid();
+  PROTOBUF_NODISCARD std::string* release_selectedid();
+  void set_allocated_selectedid(std::string* selectedid);
+  private:
+  const std::string& _internal_selectedid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedid(const std::string& value);
+  std::string* _internal_mutable_selectedid();
+  public:
+
+  // optional string selectedDisplayText = 2;
+  bool has_selecteddisplaytext() const;
+  private:
+  bool _internal_has_selecteddisplaytext() const;
+  public:
+  void clear_selecteddisplaytext();
+  const std::string& selecteddisplaytext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_selecteddisplaytext();
+  PROTOBUF_NODISCARD std::string* release_selecteddisplaytext();
+  void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext);
+  private:
+  const std::string& _internal_selecteddisplaytext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value);
+  std::string* _internal_mutable_selecteddisplaytext();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 3;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint32 selectedIndex = 4;
+  bool has_selectedindex() const;
+  private:
+  bool _internal_has_selectedindex() const;
+  public:
+  void clear_selectedindex();
+  uint32_t selectedindex() const;
+  void set_selectedindex(uint32_t value);
+  private:
+  uint32_t _internal_selectedindex() const;
+  void _internal_set_selectedindex(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.TemplateButtonReplyMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_;
+    ::proto::ContextInfo* contextinfo_;
+    uint32_t selectedindex_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_TemplateMessage_FourRowTemplate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.FourRowTemplate) */ {
+ public:
+  inline Message_TemplateMessage_FourRowTemplate() : Message_TemplateMessage_FourRowTemplate(nullptr) {}
+  ~Message_TemplateMessage_FourRowTemplate() override;
+  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from);
+  Message_TemplateMessage_FourRowTemplate(Message_TemplateMessage_FourRowTemplate&& from) noexcept
+    : Message_TemplateMessage_FourRowTemplate() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_TemplateMessage_FourRowTemplate& operator=(const Message_TemplateMessage_FourRowTemplate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_TemplateMessage_FourRowTemplate& operator=(Message_TemplateMessage_FourRowTemplate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_TemplateMessage_FourRowTemplate& default_instance() {
+    return *internal_default_instance();
+  }
+  enum TitleCase {
+    kDocumentMessage = 1,
+    kHighlyStructuredMessage = 2,
+    kImageMessage = 3,
+    kVideoMessage = 4,
+    kLocationMessage = 5,
+    TITLE_NOT_SET = 0,
+  };
+
+  static inline const Message_TemplateMessage_FourRowTemplate* internal_default_instance() {
+    return reinterpret_cast<const Message_TemplateMessage_FourRowTemplate*>(
+               &_Message_TemplateMessage_FourRowTemplate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    133;
+
+  friend void swap(Message_TemplateMessage_FourRowTemplate& a, Message_TemplateMessage_FourRowTemplate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_TemplateMessage_FourRowTemplate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_TemplateMessage_FourRowTemplate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_TemplateMessage_FourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_TemplateMessage_FourRowTemplate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_TemplateMessage_FourRowTemplate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_TemplateMessage_FourRowTemplate& from) {
+    Message_TemplateMessage_FourRowTemplate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_TemplateMessage_FourRowTemplate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.TemplateMessage.FourRowTemplate";
+  }
+  protected:
+  explicit Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kButtonsFieldNumber = 8,
+    kContentFieldNumber = 6,
+    kFooterFieldNumber = 7,
+    kDocumentMessageFieldNumber = 1,
+    kHighlyStructuredMessageFieldNumber = 2,
+    kImageMessageFieldNumber = 3,
+    kVideoMessageFieldNumber = 4,
+    kLocationMessageFieldNumber = 5,
+  };
+  // repeated .proto.TemplateButton buttons = 8;
+  int buttons_size() const;
+  private:
+  int _internal_buttons_size() const;
+  public:
+  void clear_buttons();
+  ::proto::TemplateButton* mutable_buttons(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >*
+      mutable_buttons();
+  private:
+  const ::proto::TemplateButton& _internal_buttons(int index) const;
+  ::proto::TemplateButton* _internal_add_buttons();
+  public:
+  const ::proto::TemplateButton& buttons(int index) const;
+  ::proto::TemplateButton* add_buttons();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >&
+      buttons() const;
+
+  // optional .proto.Message.HighlyStructuredMessage content = 6;
+  bool has_content() const;
+  private:
+  bool _internal_has_content() const;
+  public:
+  void clear_content();
+  const ::proto::Message_HighlyStructuredMessage& content() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_content();
+  ::proto::Message_HighlyStructuredMessage* mutable_content();
+  void set_allocated_content(::proto::Message_HighlyStructuredMessage* content);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_content() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_content();
+  public:
+  void unsafe_arena_set_allocated_content(
+      ::proto::Message_HighlyStructuredMessage* content);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_content();
+
+  // optional .proto.Message.HighlyStructuredMessage footer = 7;
+  bool has_footer() const;
+  private:
+  bool _internal_has_footer() const;
+  public:
+  void clear_footer();
+  const ::proto::Message_HighlyStructuredMessage& footer() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_footer();
+  ::proto::Message_HighlyStructuredMessage* mutable_footer();
+  void set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_footer() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_footer();
+  public:
+  void unsafe_arena_set_allocated_footer(
+      ::proto::Message_HighlyStructuredMessage* footer);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_footer();
+
+  // .proto.Message.DocumentMessage documentMessage = 1;
+  bool has_documentmessage() const;
+  private:
+  bool _internal_has_documentmessage() const;
+  public:
+  void clear_documentmessage();
+  const ::proto::Message_DocumentMessage& documentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
+  ::proto::Message_DocumentMessage* mutable_documentmessage();
+  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
+  private:
+  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
+  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
+  public:
+  void unsafe_arena_set_allocated_documentmessage(
+      ::proto::Message_DocumentMessage* documentmessage);
+  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();
+
+  // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
+  bool has_highlystructuredmessage() const;
+  private:
+  bool _internal_has_highlystructuredmessage() const;
+  public:
+  void clear_highlystructuredmessage();
+  const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage();
+  ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage();
+  void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage();
+  public:
+  void unsafe_arena_set_allocated_highlystructuredmessage(
+      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage();
+
+  // .proto.Message.ImageMessage imageMessage = 3;
+  bool has_imagemessage() const;
+  private:
+  bool _internal_has_imagemessage() const;
+  public:
+  void clear_imagemessage();
+  const ::proto::Message_ImageMessage& imagemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
+  ::proto::Message_ImageMessage* mutable_imagemessage();
+  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
+  public:
+  void unsafe_arena_set_allocated_imagemessage(
+      ::proto::Message_ImageMessage* imagemessage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();
+
+  // .proto.Message.VideoMessage videoMessage = 4;
+  bool has_videomessage() const;
+  private:
+  bool _internal_has_videomessage() const;
+  public:
+  void clear_videomessage();
+  const ::proto::Message_VideoMessage& videomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
+  ::proto::Message_VideoMessage* mutable_videomessage();
+  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
+  private:
+  const ::proto::Message_VideoMessage& _internal_videomessage() const;
+  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
+  public:
+  void unsafe_arena_set_allocated_videomessage(
+      ::proto::Message_VideoMessage* videomessage);
+  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();
+
+  // .proto.Message.LocationMessage locationMessage = 5;
+  bool has_locationmessage() const;
+  private:
+  bool _internal_has_locationmessage() const;
+  public:
+  void clear_locationmessage();
+  const ::proto::Message_LocationMessage& locationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
+  ::proto::Message_LocationMessage* mutable_locationmessage();
+  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
+  private:
+  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
+  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
+  public:
+  void unsafe_arena_set_allocated_locationmessage(
+      ::proto::Message_LocationMessage* locationmessage);
+  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();
+
+  void clear_title();
+  TitleCase title_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.FourRowTemplate)
+ private:
+  class _Internal;
+  void set_has_documentmessage();
+  void set_has_highlystructuredmessage();
+  void set_has_imagemessage();
+  void set_has_videomessage();
+  void set_has_locationmessage();
+
+  inline bool has_title() const;
+  inline void clear_has_title();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton > buttons_;
+    ::proto::Message_HighlyStructuredMessage* content_;
+    ::proto::Message_HighlyStructuredMessage* footer_;
+    union TitleUnion {
+      constexpr TitleUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_DocumentMessage* documentmessage_;
+      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_;
+      ::proto::Message_ImageMessage* imagemessage_;
+      ::proto::Message_VideoMessage* videomessage_;
+      ::proto::Message_LocationMessage* locationmessage_;
+    } title_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_TemplateMessage_HydratedFourRowTemplate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.HydratedFourRowTemplate) */ {
+ public:
+  inline Message_TemplateMessage_HydratedFourRowTemplate() : Message_TemplateMessage_HydratedFourRowTemplate(nullptr) {}
+  ~Message_TemplateMessage_HydratedFourRowTemplate() override;
+  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from);
+  Message_TemplateMessage_HydratedFourRowTemplate(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept
+    : Message_TemplateMessage_HydratedFourRowTemplate() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(const Message_TemplateMessage_HydratedFourRowTemplate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_TemplateMessage_HydratedFourRowTemplate& default_instance() {
+    return *internal_default_instance();
+  }
+  enum TitleCase {
+    kDocumentMessage = 1,
+    kHydratedTitleText = 2,
+    kImageMessage = 3,
+    kVideoMessage = 4,
+    kLocationMessage = 5,
+    TITLE_NOT_SET = 0,
+  };
+
+  static inline const Message_TemplateMessage_HydratedFourRowTemplate* internal_default_instance() {
+    return reinterpret_cast<const Message_TemplateMessage_HydratedFourRowTemplate*>(
+               &_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    134;
+
+  friend void swap(Message_TemplateMessage_HydratedFourRowTemplate& a, Message_TemplateMessage_HydratedFourRowTemplate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_TemplateMessage_HydratedFourRowTemplate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_TemplateMessage_HydratedFourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_TemplateMessage_HydratedFourRowTemplate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_TemplateMessage_HydratedFourRowTemplate& from) {
+    Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.TemplateMessage.HydratedFourRowTemplate";
+  }
+  protected:
+  explicit Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHydratedButtonsFieldNumber = 8,
+    kHydratedContentTextFieldNumber = 6,
+    kHydratedFooterTextFieldNumber = 7,
+    kTemplateIdFieldNumber = 9,
+    kDocumentMessageFieldNumber = 1,
+    kHydratedTitleTextFieldNumber = 2,
+    kImageMessageFieldNumber = 3,
+    kVideoMessageFieldNumber = 4,
+    kLocationMessageFieldNumber = 5,
+  };
+  // repeated .proto.HydratedTemplateButton hydratedButtons = 8;
+  int hydratedbuttons_size() const;
+  private:
+  int _internal_hydratedbuttons_size() const;
+  public:
+  void clear_hydratedbuttons();
+  ::proto::HydratedTemplateButton* mutable_hydratedbuttons(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >*
+      mutable_hydratedbuttons();
+  private:
+  const ::proto::HydratedTemplateButton& _internal_hydratedbuttons(int index) const;
+  ::proto::HydratedTemplateButton* _internal_add_hydratedbuttons();
+  public:
+  const ::proto::HydratedTemplateButton& hydratedbuttons(int index) const;
+  ::proto::HydratedTemplateButton* add_hydratedbuttons();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >&
+      hydratedbuttons() const;
+
+  // optional string hydratedContentText = 6;
+  bool has_hydratedcontenttext() const;
+  private:
+  bool _internal_has_hydratedcontenttext() const;
+  public:
+  void clear_hydratedcontenttext();
+  const std::string& hydratedcontenttext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hydratedcontenttext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hydratedcontenttext();
+  PROTOBUF_NODISCARD std::string* release_hydratedcontenttext();
+  void set_allocated_hydratedcontenttext(std::string* hydratedcontenttext);
+  private:
+  const std::string& _internal_hydratedcontenttext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedcontenttext(const std::string& value);
+  std::string* _internal_mutable_hydratedcontenttext();
+  public:
+
+  // optional string hydratedFooterText = 7;
+  bool has_hydratedfootertext() const;
+  private:
+  bool _internal_has_hydratedfootertext() const;
+  public:
+  void clear_hydratedfootertext();
+  const std::string& hydratedfootertext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hydratedfootertext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hydratedfootertext();
+  PROTOBUF_NODISCARD std::string* release_hydratedfootertext();
+  void set_allocated_hydratedfootertext(std::string* hydratedfootertext);
+  private:
+  const std::string& _internal_hydratedfootertext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedfootertext(const std::string& value);
+  std::string* _internal_mutable_hydratedfootertext();
+  public:
+
+  // optional string templateId = 9;
+  bool has_templateid() const;
+  private:
+  bool _internal_has_templateid() const;
+  public:
+  void clear_templateid();
+  const std::string& templateid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_templateid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_templateid();
+  PROTOBUF_NODISCARD std::string* release_templateid();
+  void set_allocated_templateid(std::string* templateid);
+  private:
+  const std::string& _internal_templateid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_templateid(const std::string& value);
+  std::string* _internal_mutable_templateid();
+  public:
+
+  // .proto.Message.DocumentMessage documentMessage = 1;
+  bool has_documentmessage() const;
+  private:
+  bool _internal_has_documentmessage() const;
+  public:
+  void clear_documentmessage();
+  const ::proto::Message_DocumentMessage& documentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
+  ::proto::Message_DocumentMessage* mutable_documentmessage();
+  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
+  private:
+  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
+  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
+  public:
+  void unsafe_arena_set_allocated_documentmessage(
+      ::proto::Message_DocumentMessage* documentmessage);
+  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();
+
+  // string hydratedTitleText = 2;
+  bool has_hydratedtitletext() const;
+  private:
+  bool _internal_has_hydratedtitletext() const;
+  public:
+  void clear_hydratedtitletext();
+  const std::string& hydratedtitletext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hydratedtitletext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hydratedtitletext();
+  PROTOBUF_NODISCARD std::string* release_hydratedtitletext();
+  void set_allocated_hydratedtitletext(std::string* hydratedtitletext);
+  private:
+  const std::string& _internal_hydratedtitletext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedtitletext(const std::string& value);
+  std::string* _internal_mutable_hydratedtitletext();
+  public:
+
+  // .proto.Message.ImageMessage imageMessage = 3;
+  bool has_imagemessage() const;
+  private:
+  bool _internal_has_imagemessage() const;
+  public:
+  void clear_imagemessage();
+  const ::proto::Message_ImageMessage& imagemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
+  ::proto::Message_ImageMessage* mutable_imagemessage();
+  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
+  public:
+  void unsafe_arena_set_allocated_imagemessage(
+      ::proto::Message_ImageMessage* imagemessage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();
+
+  // .proto.Message.VideoMessage videoMessage = 4;
+  bool has_videomessage() const;
+  private:
+  bool _internal_has_videomessage() const;
+  public:
+  void clear_videomessage();
+  const ::proto::Message_VideoMessage& videomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
+  ::proto::Message_VideoMessage* mutable_videomessage();
+  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
+  private:
+  const ::proto::Message_VideoMessage& _internal_videomessage() const;
+  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
+  public:
+  void unsafe_arena_set_allocated_videomessage(
+      ::proto::Message_VideoMessage* videomessage);
+  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();
+
+  // .proto.Message.LocationMessage locationMessage = 5;
+  bool has_locationmessage() const;
+  private:
+  bool _internal_has_locationmessage() const;
+  public:
+  void clear_locationmessage();
+  const ::proto::Message_LocationMessage& locationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
+  ::proto::Message_LocationMessage* mutable_locationmessage();
+  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
+  private:
+  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
+  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
+  public:
+  void unsafe_arena_set_allocated_locationmessage(
+      ::proto::Message_LocationMessage* locationmessage);
+  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();
+
+  void clear_title();
+  TitleCase title_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.HydratedFourRowTemplate)
+ private:
+  class _Internal;
+  void set_has_documentmessage();
+  void set_has_hydratedtitletext();
+  void set_has_imagemessage();
+  void set_has_videomessage();
+  void set_has_locationmessage();
+
+  inline bool has_title() const;
+  inline void clear_has_title();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton > hydratedbuttons_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedcontenttext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedfootertext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr templateid_;
+    union TitleUnion {
+      constexpr TitleUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_DocumentMessage* documentmessage_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedtitletext_;
+      ::proto::Message_ImageMessage* imagemessage_;
+      ::proto::Message_VideoMessage* videomessage_;
+      ::proto::Message_LocationMessage* locationmessage_;
+    } title_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_TemplateMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage) */ {
+ public:
+  inline Message_TemplateMessage() : Message_TemplateMessage(nullptr) {}
+  ~Message_TemplateMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_TemplateMessage(const Message_TemplateMessage& from);
+  Message_TemplateMessage(Message_TemplateMessage&& from) noexcept
+    : Message_TemplateMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_TemplateMessage& operator=(const Message_TemplateMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_TemplateMessage& operator=(Message_TemplateMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_TemplateMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FormatCase {
+    kFourRowTemplate = 1,
+    kHydratedFourRowTemplate = 2,
+    FORMAT_NOT_SET = 0,
+  };
+
+  static inline const Message_TemplateMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_TemplateMessage*>(
+               &_Message_TemplateMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    135;
+
+  friend void swap(Message_TemplateMessage& a, Message_TemplateMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_TemplateMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_TemplateMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_TemplateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_TemplateMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_TemplateMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_TemplateMessage& from) {
+    Message_TemplateMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_TemplateMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.TemplateMessage";
+  }
+  protected:
+  explicit Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_TemplateMessage_FourRowTemplate FourRowTemplate;
+  typedef Message_TemplateMessage_HydratedFourRowTemplate HydratedFourRowTemplate;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContextInfoFieldNumber = 3,
+    kHydratedTemplateFieldNumber = 4,
+    kFourRowTemplateFieldNumber = 1,
+    kHydratedFourRowTemplateFieldNumber = 2,
+  };
+  // optional .proto.ContextInfo contextInfo = 3;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
+  bool has_hydratedtemplate() const;
+  private:
+  bool _internal_has_hydratedtemplate() const;
+  public:
+  void clear_hydratedtemplate();
+  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedtemplate();
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedtemplate();
+  void set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate);
+  private:
+  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedtemplate() const;
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedtemplate();
+  public:
+  void unsafe_arena_set_allocated_hydratedtemplate(
+      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate);
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedtemplate();
+
+  // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
+  bool has_fourrowtemplate() const;
+  private:
+  bool _internal_has_fourrowtemplate() const;
+  public:
+  void clear_fourrowtemplate();
+  const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_FourRowTemplate* release_fourrowtemplate();
+  ::proto::Message_TemplateMessage_FourRowTemplate* mutable_fourrowtemplate();
+  void set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate);
+  private:
+  const ::proto::Message_TemplateMessage_FourRowTemplate& _internal_fourrowtemplate() const;
+  ::proto::Message_TemplateMessage_FourRowTemplate* _internal_mutable_fourrowtemplate();
+  public:
+  void unsafe_arena_set_allocated_fourrowtemplate(
+      ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate);
+  ::proto::Message_TemplateMessage_FourRowTemplate* unsafe_arena_release_fourrowtemplate();
+
+  // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
+  bool has_hydratedfourrowtemplate() const;
+  private:
+  bool _internal_has_hydratedfourrowtemplate() const;
+  public:
+  void clear_hydratedfourrowtemplate();
+  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedfourrowtemplate();
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedfourrowtemplate();
+  void set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate);
+  private:
+  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedfourrowtemplate() const;
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedfourrowtemplate();
+  public:
+  void unsafe_arena_set_allocated_hydratedfourrowtemplate(
+      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate);
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedfourrowtemplate();
+
+  void clear_format();
+  FormatCase format_case() const;
+  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage)
+ private:
+  class _Internal;
+  void set_has_fourrowtemplate();
+  void set_has_hydratedfourrowtemplate();
+
+  inline bool has_format() const;
+  inline void clear_has_format();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::ContextInfo* contextinfo_;
+    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate_;
+    union FormatUnion {
+      constexpr FormatUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate_;
+      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate_;
+    } format_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message_VideoMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.VideoMessage) */ {
+ public:
+  inline Message_VideoMessage() : Message_VideoMessage(nullptr) {}
+  ~Message_VideoMessage() override;
+  explicit PROTOBUF_CONSTEXPR Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message_VideoMessage(const Message_VideoMessage& from);
+  Message_VideoMessage(Message_VideoMessage&& from) noexcept
+    : Message_VideoMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline Message_VideoMessage& operator=(const Message_VideoMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message_VideoMessage& operator=(Message_VideoMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message_VideoMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message_VideoMessage* internal_default_instance() {
+    return reinterpret_cast<const Message_VideoMessage*>(
+               &_Message_VideoMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    136;
+
+  friend void swap(Message_VideoMessage& a, Message_VideoMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message_VideoMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message_VideoMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message_VideoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message_VideoMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message_VideoMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message_VideoMessage& from) {
+    Message_VideoMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message_VideoMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message.VideoMessage";
+  }
+  protected:
+  explicit Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_VideoMessage_Attribution Attribution;
+  static constexpr Attribution NONE =
+    Message_VideoMessage_Attribution_NONE;
+  static constexpr Attribution GIPHY =
+    Message_VideoMessage_Attribution_GIPHY;
+  static constexpr Attribution TENOR =
+    Message_VideoMessage_Attribution_TENOR;
+  static inline bool Attribution_IsValid(int value) {
+    return Message_VideoMessage_Attribution_IsValid(value);
+  }
+  static constexpr Attribution Attribution_MIN =
+    Message_VideoMessage_Attribution_Attribution_MIN;
+  static constexpr Attribution Attribution_MAX =
+    Message_VideoMessage_Attribution_Attribution_MAX;
+  static constexpr int Attribution_ARRAYSIZE =
+    Message_VideoMessage_Attribution_Attribution_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Attribution_descriptor() {
+    return Message_VideoMessage_Attribution_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Attribution_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Attribution>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Attribution_Name.");
+    return Message_VideoMessage_Attribution_Name(enum_t_value);
+  }
+  static inline bool Attribution_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Attribution* value) {
+    return Message_VideoMessage_Attribution_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInteractiveAnnotationsFieldNumber = 12,
+    kUrlFieldNumber = 1,
+    kMimetypeFieldNumber = 2,
+    kFileSha256FieldNumber = 3,
+    kMediaKeyFieldNumber = 6,
+    kCaptionFieldNumber = 7,
+    kFileEncSha256FieldNumber = 11,
+    kDirectPathFieldNumber = 13,
+    kJpegThumbnailFieldNumber = 16,
+    kStreamingSidecarFieldNumber = 18,
+    kThumbnailDirectPathFieldNumber = 21,
+    kThumbnailSha256FieldNumber = 22,
+    kThumbnailEncSha256FieldNumber = 23,
+    kStaticUrlFieldNumber = 24,
+    kContextInfoFieldNumber = 17,
+    kFileLengthFieldNumber = 4,
+    kSecondsFieldNumber = 5,
+    kHeightFieldNumber = 9,
+    kWidthFieldNumber = 10,
+    kGifPlaybackFieldNumber = 8,
+    kViewOnceFieldNumber = 20,
+    kMediaKeyTimestampFieldNumber = 14,
+    kGifAttributionFieldNumber = 19,
+  };
+  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
+  int interactiveannotations_size() const;
+  private:
+  int _internal_interactiveannotations_size() const;
+  public:
+  void clear_interactiveannotations();
+  ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
+      mutable_interactiveannotations();
+  private:
+  const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const;
+  ::proto::InteractiveAnnotation* _internal_add_interactiveannotations();
+  public:
+  const ::proto::InteractiveAnnotation& interactiveannotations(int index) const;
+  ::proto::InteractiveAnnotation* add_interactiveannotations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
+      interactiveannotations() const;
+
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string mimetype = 2;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional bytes fileSha256 = 3;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes mediaKey = 6;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string caption = 7;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional bytes fileEncSha256 = 11;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 13;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional bytes jpegThumbnail = 16;
+  bool has_jpegthumbnail() const;
+  private:
+  bool _internal_has_jpegthumbnail() const;
+  public:
+  void clear_jpegthumbnail();
+  const std::string& jpegthumbnail() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_jpegthumbnail();
+  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
+  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
+  private:
+  const std::string& _internal_jpegthumbnail() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
+  std::string* _internal_mutable_jpegthumbnail();
+  public:
+
+  // optional bytes streamingSidecar = 18;
+  bool has_streamingsidecar() const;
+  private:
+  bool _internal_has_streamingsidecar() const;
+  public:
+  void clear_streamingsidecar();
+  const std::string& streamingsidecar() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_streamingsidecar(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_streamingsidecar();
+  PROTOBUF_NODISCARD std::string* release_streamingsidecar();
+  void set_allocated_streamingsidecar(std::string* streamingsidecar);
+  private:
+  const std::string& _internal_streamingsidecar() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value);
+  std::string* _internal_mutable_streamingsidecar();
+  public:
+
+  // optional string thumbnailDirectPath = 21;
+  bool has_thumbnaildirectpath() const;
+  private:
+  bool _internal_has_thumbnaildirectpath() const;
+  public:
+  void clear_thumbnaildirectpath();
+  const std::string& thumbnaildirectpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnaildirectpath();
+  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
+  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
+  private:
+  const std::string& _internal_thumbnaildirectpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
+  std::string* _internal_mutable_thumbnaildirectpath();
+  public:
+
+  // optional bytes thumbnailSha256 = 22;
+  bool has_thumbnailsha256() const;
+  private:
+  bool _internal_has_thumbnailsha256() const;
+  public:
+  void clear_thumbnailsha256();
+  const std::string& thumbnailsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
+  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
+  private:
+  const std::string& _internal_thumbnailsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailsha256();
+  public:
+
+  // optional bytes thumbnailEncSha256 = 23;
+  bool has_thumbnailencsha256() const;
+  private:
+  bool _internal_has_thumbnailencsha256() const;
+  public:
+  void clear_thumbnailencsha256();
+  const std::string& thumbnailencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_thumbnailencsha256();
+  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
+  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
+  private:
+  const std::string& _internal_thumbnailencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
+  std::string* _internal_mutable_thumbnailencsha256();
+  public:
+
+  // optional string staticUrl = 24;
+  bool has_staticurl() const;
+  private:
+  bool _internal_has_staticurl() const;
+  public:
+  void clear_staticurl();
+  const std::string& staticurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_staticurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_staticurl();
+  PROTOBUF_NODISCARD std::string* release_staticurl();
+  void set_allocated_staticurl(std::string* staticurl);
+  private:
+  const std::string& _internal_staticurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value);
+  std::string* _internal_mutable_staticurl();
+  public:
+
+  // optional .proto.ContextInfo contextInfo = 17;
+  bool has_contextinfo() const;
+  private:
+  bool _internal_has_contextinfo() const;
+  public:
+  void clear_contextinfo();
+  const ::proto::ContextInfo& contextinfo() const;
+  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
+  ::proto::ContextInfo* mutable_contextinfo();
+  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
+  private:
+  const ::proto::ContextInfo& _internal_contextinfo() const;
+  ::proto::ContextInfo* _internal_mutable_contextinfo();
+  public:
+  void unsafe_arena_set_allocated_contextinfo(
+      ::proto::ContextInfo* contextinfo);
+  ::proto::ContextInfo* unsafe_arena_release_contextinfo();
+
+  // optional uint64 fileLength = 4;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional uint32 seconds = 5;
+  bool has_seconds() const;
+  private:
+  bool _internal_has_seconds() const;
+  public:
+  void clear_seconds();
+  uint32_t seconds() const;
+  void set_seconds(uint32_t value);
+  private:
+  uint32_t _internal_seconds() const;
+  void _internal_set_seconds(uint32_t value);
+  public:
+
+  // optional uint32 height = 9;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional uint32 width = 10;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional bool gifPlayback = 8;
+  bool has_gifplayback() const;
+  private:
+  bool _internal_has_gifplayback() const;
+  public:
+  void clear_gifplayback();
+  bool gifplayback() const;
+  void set_gifplayback(bool value);
+  private:
+  bool _internal_gifplayback() const;
+  void _internal_set_gifplayback(bool value);
+  public:
+
+  // optional bool viewOnce = 20;
+  bool has_viewonce() const;
+  private:
+  bool _internal_has_viewonce() const;
+  public:
+  void clear_viewonce();
+  bool viewonce() const;
+  void set_viewonce(bool value);
+  private:
+  bool _internal_viewonce() const;
+  void _internal_set_viewonce(bool value);
+  public:
+
+  // optional int64 mediaKeyTimestamp = 14;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
+  bool has_gifattribution() const;
+  private:
+  bool _internal_has_gifattribution() const;
+  public:
+  void clear_gifattribution();
+  ::proto::Message_VideoMessage_Attribution gifattribution() const;
+  void set_gifattribution(::proto::Message_VideoMessage_Attribution value);
+  private:
+  ::proto::Message_VideoMessage_Attribution _internal_gifattribution() const;
+  void _internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Message.VideoMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_;
+    ::proto::ContextInfo* contextinfo_;
+    uint64_t filelength_;
+    uint32_t seconds_;
+    uint32_t height_;
+    uint32_t width_;
+    bool gifplayback_;
+    bool viewonce_;
+    int64_t mediakeytimestamp_;
+    int gifattribution_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Message final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message) */ {
+ public:
+  inline Message() : Message(nullptr) {}
+  ~Message() override;
+  explicit PROTOBUF_CONSTEXPR Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Message(const Message& from);
+  Message(Message&& from) noexcept
+    : Message() {
+    *this = ::std::move(from);
+  }
+
+  inline Message& operator=(const Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Message& operator=(Message&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Message& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Message* internal_default_instance() {
+    return reinterpret_cast<const Message*>(
+               &_Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    137;
+
+  friend void swap(Message& a, Message& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Message* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Message* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Message>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Message& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Message& from) {
+    Message::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Message* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Message";
+  }
+  protected:
+  explicit Message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Message_AppStateFatalExceptionNotification AppStateFatalExceptionNotification;
+  typedef Message_AppStateSyncKeyData AppStateSyncKeyData;
+  typedef Message_AppStateSyncKeyFingerprint AppStateSyncKeyFingerprint;
+  typedef Message_AppStateSyncKeyId AppStateSyncKeyId;
+  typedef Message_AppStateSyncKeyRequest AppStateSyncKeyRequest;
+  typedef Message_AppStateSyncKeyShare AppStateSyncKeyShare;
+  typedef Message_AppStateSyncKey AppStateSyncKey;
+  typedef Message_AudioMessage AudioMessage;
+  typedef Message_ButtonsMessage ButtonsMessage;
+  typedef Message_ButtonsResponseMessage ButtonsResponseMessage;
+  typedef Message_Call Call;
+  typedef Message_CancelPaymentRequestMessage CancelPaymentRequestMessage;
+  typedef Message_Chat Chat;
+  typedef Message_ContactMessage ContactMessage;
+  typedef Message_ContactsArrayMessage ContactsArrayMessage;
+  typedef Message_DeclinePaymentRequestMessage DeclinePaymentRequestMessage;
+  typedef Message_DeviceSentMessage DeviceSentMessage;
+  typedef Message_DocumentMessage DocumentMessage;
+  typedef Message_ExtendedTextMessage ExtendedTextMessage;
+  typedef Message_FutureProofMessage FutureProofMessage;
+  typedef Message_GroupInviteMessage GroupInviteMessage;
+  typedef Message_HighlyStructuredMessage HighlyStructuredMessage;
+  typedef Message_HistorySyncNotification HistorySyncNotification;
+  typedef Message_ImageMessage ImageMessage;
+  typedef Message_InitialSecurityNotificationSettingSync InitialSecurityNotificationSettingSync;
+  typedef Message_InteractiveMessage InteractiveMessage;
+  typedef Message_InteractiveResponseMessage InteractiveResponseMessage;
+  typedef Message_InvoiceMessage InvoiceMessage;
+  typedef Message_KeepInChatMessage KeepInChatMessage;
+  typedef Message_ListMessage ListMessage;
+  typedef Message_ListResponseMessage ListResponseMessage;
+  typedef Message_LiveLocationMessage LiveLocationMessage;
+  typedef Message_LocationMessage LocationMessage;
+  typedef Message_OrderMessage OrderMessage;
+  typedef Message_PaymentInviteMessage PaymentInviteMessage;
+  typedef Message_PollCreationMessage PollCreationMessage;
+  typedef Message_PollEncValue PollEncValue;
+  typedef Message_PollUpdateMessageMetadata PollUpdateMessageMetadata;
+  typedef Message_PollUpdateMessage PollUpdateMessage;
+  typedef Message_PollVoteMessage PollVoteMessage;
+  typedef Message_ProductMessage ProductMessage;
+  typedef Message_ProtocolMessage ProtocolMessage;
+  typedef Message_ReactionMessage ReactionMessage;
+  typedef Message_RequestMediaUploadMessage RequestMediaUploadMessage;
+  typedef Message_RequestMediaUploadResponseMessage RequestMediaUploadResponseMessage;
+  typedef Message_RequestPaymentMessage RequestPaymentMessage;
+  typedef Message_RequestPhoneNumberMessage RequestPhoneNumberMessage;
+  typedef Message_SendPaymentMessage SendPaymentMessage;
+  typedef Message_SenderKeyDistributionMessage SenderKeyDistributionMessage;
+  typedef Message_StickerMessage StickerMessage;
+  typedef Message_StickerSyncRMRMessage StickerSyncRMRMessage;
+  typedef Message_TemplateButtonReplyMessage TemplateButtonReplyMessage;
+  typedef Message_TemplateMessage TemplateMessage;
+  typedef Message_VideoMessage VideoMessage;
+
+  typedef Message_RmrSource RmrSource;
+  static constexpr RmrSource FAVORITE_STICKER =
+    Message_RmrSource_FAVORITE_STICKER;
+  static constexpr RmrSource RECENT_STICKER =
+    Message_RmrSource_RECENT_STICKER;
+  static inline bool RmrSource_IsValid(int value) {
+    return Message_RmrSource_IsValid(value);
+  }
+  static constexpr RmrSource RmrSource_MIN =
+    Message_RmrSource_RmrSource_MIN;
+  static constexpr RmrSource RmrSource_MAX =
+    Message_RmrSource_RmrSource_MAX;
+  static constexpr int RmrSource_ARRAYSIZE =
+    Message_RmrSource_RmrSource_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  RmrSource_descriptor() {
+    return Message_RmrSource_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& RmrSource_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, RmrSource>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function RmrSource_Name.");
+    return Message_RmrSource_Name(enum_t_value);
+  }
+  static inline bool RmrSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      RmrSource* value) {
+    return Message_RmrSource_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConversationFieldNumber = 1,
+    kSenderKeyDistributionMessageFieldNumber = 2,
+    kImageMessageFieldNumber = 3,
+    kContactMessageFieldNumber = 4,
+    kLocationMessageFieldNumber = 5,
+    kExtendedTextMessageFieldNumber = 6,
+    kDocumentMessageFieldNumber = 7,
+    kAudioMessageFieldNumber = 8,
+    kVideoMessageFieldNumber = 9,
+    kCallFieldNumber = 10,
+    kChatFieldNumber = 11,
+    kProtocolMessageFieldNumber = 12,
+    kContactsArrayMessageFieldNumber = 13,
+    kHighlyStructuredMessageFieldNumber = 14,
+    kFastRatchetKeySenderKeyDistributionMessageFieldNumber = 15,
+    kSendPaymentMessageFieldNumber = 16,
+    kLiveLocationMessageFieldNumber = 18,
+    kRequestPaymentMessageFieldNumber = 22,
+    kDeclinePaymentRequestMessageFieldNumber = 23,
+    kCancelPaymentRequestMessageFieldNumber = 24,
+    kTemplateMessageFieldNumber = 25,
+    kStickerMessageFieldNumber = 26,
+    kGroupInviteMessageFieldNumber = 28,
+    kTemplateButtonReplyMessageFieldNumber = 29,
+    kProductMessageFieldNumber = 30,
+    kDeviceSentMessageFieldNumber = 31,
+    kMessageContextInfoFieldNumber = 35,
+    kListMessageFieldNumber = 36,
+    kViewOnceMessageFieldNumber = 37,
+    kOrderMessageFieldNumber = 38,
+    kListResponseMessageFieldNumber = 39,
+    kEphemeralMessageFieldNumber = 40,
+    kInvoiceMessageFieldNumber = 41,
+    kButtonsMessageFieldNumber = 42,
+    kButtonsResponseMessageFieldNumber = 43,
+    kPaymentInviteMessageFieldNumber = 44,
+    kInteractiveMessageFieldNumber = 45,
+    kReactionMessageFieldNumber = 46,
+    kStickerSyncRmrMessageFieldNumber = 47,
+    kInteractiveResponseMessageFieldNumber = 48,
+    kPollCreationMessageFieldNumber = 49,
+    kPollUpdateMessageFieldNumber = 50,
+    kKeepInChatMessageFieldNumber = 51,
+    kDocumentWithCaptionMessageFieldNumber = 53,
+    kRequestPhoneNumberMessageFieldNumber = 54,
+    kViewOnceMessageV2FieldNumber = 55,
+  };
+  // optional string conversation = 1;
+  bool has_conversation() const;
+  private:
+  bool _internal_has_conversation() const;
+  public:
+  void clear_conversation();
+  const std::string& conversation() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_conversation(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_conversation();
+  PROTOBUF_NODISCARD std::string* release_conversation();
+  void set_allocated_conversation(std::string* conversation);
+  private:
+  const std::string& _internal_conversation() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversation(const std::string& value);
+  std::string* _internal_mutable_conversation();
+  public:
+
+  // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+  bool has_senderkeydistributionmessage() const;
+  private:
+  bool _internal_has_senderkeydistributionmessage() const;
+  public:
+  void clear_senderkeydistributionmessage();
+  const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_senderkeydistributionmessage();
+  ::proto::Message_SenderKeyDistributionMessage* mutable_senderkeydistributionmessage();
+  void set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage);
+  private:
+  const ::proto::Message_SenderKeyDistributionMessage& _internal_senderkeydistributionmessage() const;
+  ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_senderkeydistributionmessage();
+  public:
+  void unsafe_arena_set_allocated_senderkeydistributionmessage(
+      ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage);
+  ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_senderkeydistributionmessage();
+
+  // optional .proto.Message.ImageMessage imageMessage = 3;
+  bool has_imagemessage() const;
+  private:
+  bool _internal_has_imagemessage() const;
+  public:
+  void clear_imagemessage();
+  const ::proto::Message_ImageMessage& imagemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
+  ::proto::Message_ImageMessage* mutable_imagemessage();
+  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
+  private:
+  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
+  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
+  public:
+  void unsafe_arena_set_allocated_imagemessage(
+      ::proto::Message_ImageMessage* imagemessage);
+  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();
+
+  // optional .proto.Message.ContactMessage contactMessage = 4;
+  bool has_contactmessage() const;
+  private:
+  bool _internal_has_contactmessage() const;
+  public:
+  void clear_contactmessage();
+  const ::proto::Message_ContactMessage& contactmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ContactMessage* release_contactmessage();
+  ::proto::Message_ContactMessage* mutable_contactmessage();
+  void set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage);
+  private:
+  const ::proto::Message_ContactMessage& _internal_contactmessage() const;
+  ::proto::Message_ContactMessage* _internal_mutable_contactmessage();
+  public:
+  void unsafe_arena_set_allocated_contactmessage(
+      ::proto::Message_ContactMessage* contactmessage);
+  ::proto::Message_ContactMessage* unsafe_arena_release_contactmessage();
+
+  // optional .proto.Message.LocationMessage locationMessage = 5;
+  bool has_locationmessage() const;
+  private:
+  bool _internal_has_locationmessage() const;
+  public:
+  void clear_locationmessage();
+  const ::proto::Message_LocationMessage& locationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
+  ::proto::Message_LocationMessage* mutable_locationmessage();
+  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
+  private:
+  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
+  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
+  public:
+  void unsafe_arena_set_allocated_locationmessage(
+      ::proto::Message_LocationMessage* locationmessage);
+  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();
+
+  // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
+  bool has_extendedtextmessage() const;
+  private:
+  bool _internal_has_extendedtextmessage() const;
+  public:
+  void clear_extendedtextmessage();
+  const ::proto::Message_ExtendedTextMessage& extendedtextmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ExtendedTextMessage* release_extendedtextmessage();
+  ::proto::Message_ExtendedTextMessage* mutable_extendedtextmessage();
+  void set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage);
+  private:
+  const ::proto::Message_ExtendedTextMessage& _internal_extendedtextmessage() const;
+  ::proto::Message_ExtendedTextMessage* _internal_mutable_extendedtextmessage();
+  public:
+  void unsafe_arena_set_allocated_extendedtextmessage(
+      ::proto::Message_ExtendedTextMessage* extendedtextmessage);
+  ::proto::Message_ExtendedTextMessage* unsafe_arena_release_extendedtextmessage();
+
+  // optional .proto.Message.DocumentMessage documentMessage = 7;
+  bool has_documentmessage() const;
+  private:
+  bool _internal_has_documentmessage() const;
+  public:
+  void clear_documentmessage();
+  const ::proto::Message_DocumentMessage& documentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
+  ::proto::Message_DocumentMessage* mutable_documentmessage();
+  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
+  private:
+  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
+  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
+  public:
+  void unsafe_arena_set_allocated_documentmessage(
+      ::proto::Message_DocumentMessage* documentmessage);
+  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();
+
+  // optional .proto.Message.AudioMessage audioMessage = 8;
+  bool has_audiomessage() const;
+  private:
+  bool _internal_has_audiomessage() const;
+  public:
+  void clear_audiomessage();
+  const ::proto::Message_AudioMessage& audiomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_AudioMessage* release_audiomessage();
+  ::proto::Message_AudioMessage* mutable_audiomessage();
+  void set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage);
+  private:
+  const ::proto::Message_AudioMessage& _internal_audiomessage() const;
+  ::proto::Message_AudioMessage* _internal_mutable_audiomessage();
+  public:
+  void unsafe_arena_set_allocated_audiomessage(
+      ::proto::Message_AudioMessage* audiomessage);
+  ::proto::Message_AudioMessage* unsafe_arena_release_audiomessage();
+
+  // optional .proto.Message.VideoMessage videoMessage = 9;
+  bool has_videomessage() const;
+  private:
+  bool _internal_has_videomessage() const;
+  public:
+  void clear_videomessage();
+  const ::proto::Message_VideoMessage& videomessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
+  ::proto::Message_VideoMessage* mutable_videomessage();
+  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
+  private:
+  const ::proto::Message_VideoMessage& _internal_videomessage() const;
+  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
+  public:
+  void unsafe_arena_set_allocated_videomessage(
+      ::proto::Message_VideoMessage* videomessage);
+  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();
+
+  // optional .proto.Message.Call call = 10;
+  bool has_call() const;
+  private:
+  bool _internal_has_call() const;
+  public:
+  void clear_call();
+  const ::proto::Message_Call& call() const;
+  PROTOBUF_NODISCARD ::proto::Message_Call* release_call();
+  ::proto::Message_Call* mutable_call();
+  void set_allocated_call(::proto::Message_Call* call);
+  private:
+  const ::proto::Message_Call& _internal_call() const;
+  ::proto::Message_Call* _internal_mutable_call();
+  public:
+  void unsafe_arena_set_allocated_call(
+      ::proto::Message_Call* call);
+  ::proto::Message_Call* unsafe_arena_release_call();
+
+  // optional .proto.Message.Chat chat = 11;
+  bool has_chat() const;
+  private:
+  bool _internal_has_chat() const;
+  public:
+  void clear_chat();
+  const ::proto::Message_Chat& chat() const;
+  PROTOBUF_NODISCARD ::proto::Message_Chat* release_chat();
+  ::proto::Message_Chat* mutable_chat();
+  void set_allocated_chat(::proto::Message_Chat* chat);
+  private:
+  const ::proto::Message_Chat& _internal_chat() const;
+  ::proto::Message_Chat* _internal_mutable_chat();
+  public:
+  void unsafe_arena_set_allocated_chat(
+      ::proto::Message_Chat* chat);
+  ::proto::Message_Chat* unsafe_arena_release_chat();
+
+  // optional .proto.Message.ProtocolMessage protocolMessage = 12;
+  bool has_protocolmessage() const;
+  private:
+  bool _internal_has_protocolmessage() const;
+  public:
+  void clear_protocolmessage();
+  const ::proto::Message_ProtocolMessage& protocolmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ProtocolMessage* release_protocolmessage();
+  ::proto::Message_ProtocolMessage* mutable_protocolmessage();
+  void set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage);
+  private:
+  const ::proto::Message_ProtocolMessage& _internal_protocolmessage() const;
+  ::proto::Message_ProtocolMessage* _internal_mutable_protocolmessage();
+  public:
+  void unsafe_arena_set_allocated_protocolmessage(
+      ::proto::Message_ProtocolMessage* protocolmessage);
+  ::proto::Message_ProtocolMessage* unsafe_arena_release_protocolmessage();
+
+  // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
+  bool has_contactsarraymessage() const;
+  private:
+  bool _internal_has_contactsarraymessage() const;
+  public:
+  void clear_contactsarraymessage();
+  const ::proto::Message_ContactsArrayMessage& contactsarraymessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ContactsArrayMessage* release_contactsarraymessage();
+  ::proto::Message_ContactsArrayMessage* mutable_contactsarraymessage();
+  void set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage);
+  private:
+  const ::proto::Message_ContactsArrayMessage& _internal_contactsarraymessage() const;
+  ::proto::Message_ContactsArrayMessage* _internal_mutable_contactsarraymessage();
+  public:
+  void unsafe_arena_set_allocated_contactsarraymessage(
+      ::proto::Message_ContactsArrayMessage* contactsarraymessage);
+  ::proto::Message_ContactsArrayMessage* unsafe_arena_release_contactsarraymessage();
+
+  // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
+  bool has_highlystructuredmessage() const;
+  private:
+  bool _internal_has_highlystructuredmessage() const;
+  public:
+  void clear_highlystructuredmessage();
+  const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage();
+  ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage();
+  void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage();
+  public:
+  void unsafe_arena_set_allocated_highlystructuredmessage(
+      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage();
+
+  // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+  bool has_fastratchetkeysenderkeydistributionmessage() const;
+  private:
+  bool _internal_has_fastratchetkeysenderkeydistributionmessage() const;
+  public:
+  void clear_fastratchetkeysenderkeydistributionmessage();
+  const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_fastratchetkeysenderkeydistributionmessage();
+  ::proto::Message_SenderKeyDistributionMessage* mutable_fastratchetkeysenderkeydistributionmessage();
+  void set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage);
+  private:
+  const ::proto::Message_SenderKeyDistributionMessage& _internal_fastratchetkeysenderkeydistributionmessage() const;
+  ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_fastratchetkeysenderkeydistributionmessage();
+  public:
+  void unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage(
+      ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage);
+  ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_fastratchetkeysenderkeydistributionmessage();
+
+  // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
+  bool has_sendpaymentmessage() const;
+  private:
+  bool _internal_has_sendpaymentmessage() const;
+  public:
+  void clear_sendpaymentmessage();
+  const ::proto::Message_SendPaymentMessage& sendpaymentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_SendPaymentMessage* release_sendpaymentmessage();
+  ::proto::Message_SendPaymentMessage* mutable_sendpaymentmessage();
+  void set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage);
+  private:
+  const ::proto::Message_SendPaymentMessage& _internal_sendpaymentmessage() const;
+  ::proto::Message_SendPaymentMessage* _internal_mutable_sendpaymentmessage();
+  public:
+  void unsafe_arena_set_allocated_sendpaymentmessage(
+      ::proto::Message_SendPaymentMessage* sendpaymentmessage);
+  ::proto::Message_SendPaymentMessage* unsafe_arena_release_sendpaymentmessage();
+
+  // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
+  bool has_livelocationmessage() const;
+  private:
+  bool _internal_has_livelocationmessage() const;
+  public:
+  void clear_livelocationmessage();
+  const ::proto::Message_LiveLocationMessage& livelocationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_livelocationmessage();
+  ::proto::Message_LiveLocationMessage* mutable_livelocationmessage();
+  void set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage);
+  private:
+  const ::proto::Message_LiveLocationMessage& _internal_livelocationmessage() const;
+  ::proto::Message_LiveLocationMessage* _internal_mutable_livelocationmessage();
+  public:
+  void unsafe_arena_set_allocated_livelocationmessage(
+      ::proto::Message_LiveLocationMessage* livelocationmessage);
+  ::proto::Message_LiveLocationMessage* unsafe_arena_release_livelocationmessage();
+
+  // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
+  bool has_requestpaymentmessage() const;
+  private:
+  bool _internal_has_requestpaymentmessage() const;
+  public:
+  void clear_requestpaymentmessage();
+  const ::proto::Message_RequestPaymentMessage& requestpaymentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_RequestPaymentMessage* release_requestpaymentmessage();
+  ::proto::Message_RequestPaymentMessage* mutable_requestpaymentmessage();
+  void set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage);
+  private:
+  const ::proto::Message_RequestPaymentMessage& _internal_requestpaymentmessage() const;
+  ::proto::Message_RequestPaymentMessage* _internal_mutable_requestpaymentmessage();
+  public:
+  void unsafe_arena_set_allocated_requestpaymentmessage(
+      ::proto::Message_RequestPaymentMessage* requestpaymentmessage);
+  ::proto::Message_RequestPaymentMessage* unsafe_arena_release_requestpaymentmessage();
+
+  // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+  bool has_declinepaymentrequestmessage() const;
+  private:
+  bool _internal_has_declinepaymentrequestmessage() const;
+  public:
+  void clear_declinepaymentrequestmessage();
+  const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DeclinePaymentRequestMessage* release_declinepaymentrequestmessage();
+  ::proto::Message_DeclinePaymentRequestMessage* mutable_declinepaymentrequestmessage();
+  void set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage);
+  private:
+  const ::proto::Message_DeclinePaymentRequestMessage& _internal_declinepaymentrequestmessage() const;
+  ::proto::Message_DeclinePaymentRequestMessage* _internal_mutable_declinepaymentrequestmessage();
+  public:
+  void unsafe_arena_set_allocated_declinepaymentrequestmessage(
+      ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage);
+  ::proto::Message_DeclinePaymentRequestMessage* unsafe_arena_release_declinepaymentrequestmessage();
+
+  // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+  bool has_cancelpaymentrequestmessage() const;
+  private:
+  bool _internal_has_cancelpaymentrequestmessage() const;
+  public:
+  void clear_cancelpaymentrequestmessage();
+  const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_CancelPaymentRequestMessage* release_cancelpaymentrequestmessage();
+  ::proto::Message_CancelPaymentRequestMessage* mutable_cancelpaymentrequestmessage();
+  void set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage);
+  private:
+  const ::proto::Message_CancelPaymentRequestMessage& _internal_cancelpaymentrequestmessage() const;
+  ::proto::Message_CancelPaymentRequestMessage* _internal_mutable_cancelpaymentrequestmessage();
+  public:
+  void unsafe_arena_set_allocated_cancelpaymentrequestmessage(
+      ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage);
+  ::proto::Message_CancelPaymentRequestMessage* unsafe_arena_release_cancelpaymentrequestmessage();
+
+  // optional .proto.Message.TemplateMessage templateMessage = 25;
+  bool has_templatemessage() const;
+  private:
+  bool _internal_has_templatemessage() const;
+  public:
+  void clear_templatemessage();
+  const ::proto::Message_TemplateMessage& templatemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_templatemessage();
+  ::proto::Message_TemplateMessage* mutable_templatemessage();
+  void set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage);
+  private:
+  const ::proto::Message_TemplateMessage& _internal_templatemessage() const;
+  ::proto::Message_TemplateMessage* _internal_mutable_templatemessage();
+  public:
+  void unsafe_arena_set_allocated_templatemessage(
+      ::proto::Message_TemplateMessage* templatemessage);
+  ::proto::Message_TemplateMessage* unsafe_arena_release_templatemessage();
+
+  // optional .proto.Message.StickerMessage stickerMessage = 26;
+  bool has_stickermessage() const;
+  private:
+  bool _internal_has_stickermessage() const;
+  public:
+  void clear_stickermessage();
+  const ::proto::Message_StickerMessage& stickermessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage();
+  ::proto::Message_StickerMessage* mutable_stickermessage();
+  void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage);
+  private:
+  const ::proto::Message_StickerMessage& _internal_stickermessage() const;
+  ::proto::Message_StickerMessage* _internal_mutable_stickermessage();
+  public:
+  void unsafe_arena_set_allocated_stickermessage(
+      ::proto::Message_StickerMessage* stickermessage);
+  ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage();
+
+  // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
+  bool has_groupinvitemessage() const;
+  private:
+  bool _internal_has_groupinvitemessage() const;
+  public:
+  void clear_groupinvitemessage();
+  const ::proto::Message_GroupInviteMessage& groupinvitemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_GroupInviteMessage* release_groupinvitemessage();
+  ::proto::Message_GroupInviteMessage* mutable_groupinvitemessage();
+  void set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage);
+  private:
+  const ::proto::Message_GroupInviteMessage& _internal_groupinvitemessage() const;
+  ::proto::Message_GroupInviteMessage* _internal_mutable_groupinvitemessage();
+  public:
+  void unsafe_arena_set_allocated_groupinvitemessage(
+      ::proto::Message_GroupInviteMessage* groupinvitemessage);
+  ::proto::Message_GroupInviteMessage* unsafe_arena_release_groupinvitemessage();
+
+  // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+  bool has_templatebuttonreplymessage() const;
+  private:
+  bool _internal_has_templatebuttonreplymessage() const;
+  public:
+  void clear_templatebuttonreplymessage();
+  const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_TemplateButtonReplyMessage* release_templatebuttonreplymessage();
+  ::proto::Message_TemplateButtonReplyMessage* mutable_templatebuttonreplymessage();
+  void set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage);
+  private:
+  const ::proto::Message_TemplateButtonReplyMessage& _internal_templatebuttonreplymessage() const;
+  ::proto::Message_TemplateButtonReplyMessage* _internal_mutable_templatebuttonreplymessage();
+  public:
+  void unsafe_arena_set_allocated_templatebuttonreplymessage(
+      ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage);
+  ::proto::Message_TemplateButtonReplyMessage* unsafe_arena_release_templatebuttonreplymessage();
+
+  // optional .proto.Message.ProductMessage productMessage = 30;
+  bool has_productmessage() const;
+  private:
+  bool _internal_has_productmessage() const;
+  public:
+  void clear_productmessage();
+  const ::proto::Message_ProductMessage& productmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ProductMessage* release_productmessage();
+  ::proto::Message_ProductMessage* mutable_productmessage();
+  void set_allocated_productmessage(::proto::Message_ProductMessage* productmessage);
+  private:
+  const ::proto::Message_ProductMessage& _internal_productmessage() const;
+  ::proto::Message_ProductMessage* _internal_mutable_productmessage();
+  public:
+  void unsafe_arena_set_allocated_productmessage(
+      ::proto::Message_ProductMessage* productmessage);
+  ::proto::Message_ProductMessage* unsafe_arena_release_productmessage();
+
+  // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
+  bool has_devicesentmessage() const;
+  private:
+  bool _internal_has_devicesentmessage() const;
+  public:
+  void clear_devicesentmessage();
+  const ::proto::Message_DeviceSentMessage& devicesentmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_DeviceSentMessage* release_devicesentmessage();
+  ::proto::Message_DeviceSentMessage* mutable_devicesentmessage();
+  void set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage);
+  private:
+  const ::proto::Message_DeviceSentMessage& _internal_devicesentmessage() const;
+  ::proto::Message_DeviceSentMessage* _internal_mutable_devicesentmessage();
+  public:
+  void unsafe_arena_set_allocated_devicesentmessage(
+      ::proto::Message_DeviceSentMessage* devicesentmessage);
+  ::proto::Message_DeviceSentMessage* unsafe_arena_release_devicesentmessage();
+
+  // optional .proto.MessageContextInfo messageContextInfo = 35;
+  bool has_messagecontextinfo() const;
+  private:
+  bool _internal_has_messagecontextinfo() const;
+  public:
+  void clear_messagecontextinfo();
+  const ::proto::MessageContextInfo& messagecontextinfo() const;
+  PROTOBUF_NODISCARD ::proto::MessageContextInfo* release_messagecontextinfo();
+  ::proto::MessageContextInfo* mutable_messagecontextinfo();
+  void set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo);
+  private:
+  const ::proto::MessageContextInfo& _internal_messagecontextinfo() const;
+  ::proto::MessageContextInfo* _internal_mutable_messagecontextinfo();
+  public:
+  void unsafe_arena_set_allocated_messagecontextinfo(
+      ::proto::MessageContextInfo* messagecontextinfo);
+  ::proto::MessageContextInfo* unsafe_arena_release_messagecontextinfo();
+
+  // optional .proto.Message.ListMessage listMessage = 36;
+  bool has_listmessage() const;
+  private:
+  bool _internal_has_listmessage() const;
+  public:
+  void clear_listmessage();
+  const ::proto::Message_ListMessage& listmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ListMessage* release_listmessage();
+  ::proto::Message_ListMessage* mutable_listmessage();
+  void set_allocated_listmessage(::proto::Message_ListMessage* listmessage);
+  private:
+  const ::proto::Message_ListMessage& _internal_listmessage() const;
+  ::proto::Message_ListMessage* _internal_mutable_listmessage();
+  public:
+  void unsafe_arena_set_allocated_listmessage(
+      ::proto::Message_ListMessage* listmessage);
+  ::proto::Message_ListMessage* unsafe_arena_release_listmessage();
+
+  // optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
+  bool has_viewoncemessage() const;
+  private:
+  bool _internal_has_viewoncemessage() const;
+  public:
+  void clear_viewoncemessage();
+  const ::proto::Message_FutureProofMessage& viewoncemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessage();
+  ::proto::Message_FutureProofMessage* mutable_viewoncemessage();
+  void set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage);
+  private:
+  const ::proto::Message_FutureProofMessage& _internal_viewoncemessage() const;
+  ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessage();
+  public:
+  void unsafe_arena_set_allocated_viewoncemessage(
+      ::proto::Message_FutureProofMessage* viewoncemessage);
+  ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessage();
+
+  // optional .proto.Message.OrderMessage orderMessage = 38;
+  bool has_ordermessage() const;
+  private:
+  bool _internal_has_ordermessage() const;
+  public:
+  void clear_ordermessage();
+  const ::proto::Message_OrderMessage& ordermessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_OrderMessage* release_ordermessage();
+  ::proto::Message_OrderMessage* mutable_ordermessage();
+  void set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage);
+  private:
+  const ::proto::Message_OrderMessage& _internal_ordermessage() const;
+  ::proto::Message_OrderMessage* _internal_mutable_ordermessage();
+  public:
+  void unsafe_arena_set_allocated_ordermessage(
+      ::proto::Message_OrderMessage* ordermessage);
+  ::proto::Message_OrderMessage* unsafe_arena_release_ordermessage();
+
+  // optional .proto.Message.ListResponseMessage listResponseMessage = 39;
+  bool has_listresponsemessage() const;
+  private:
+  bool _internal_has_listresponsemessage() const;
+  public:
+  void clear_listresponsemessage();
+  const ::proto::Message_ListResponseMessage& listresponsemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage* release_listresponsemessage();
+  ::proto::Message_ListResponseMessage* mutable_listresponsemessage();
+  void set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage);
+  private:
+  const ::proto::Message_ListResponseMessage& _internal_listresponsemessage() const;
+  ::proto::Message_ListResponseMessage* _internal_mutable_listresponsemessage();
+  public:
+  void unsafe_arena_set_allocated_listresponsemessage(
+      ::proto::Message_ListResponseMessage* listresponsemessage);
+  ::proto::Message_ListResponseMessage* unsafe_arena_release_listresponsemessage();
+
+  // optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
+  bool has_ephemeralmessage() const;
+  private:
+  bool _internal_has_ephemeralmessage() const;
+  public:
+  void clear_ephemeralmessage();
+  const ::proto::Message_FutureProofMessage& ephemeralmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_ephemeralmessage();
+  ::proto::Message_FutureProofMessage* mutable_ephemeralmessage();
+  void set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage);
+  private:
+  const ::proto::Message_FutureProofMessage& _internal_ephemeralmessage() const;
+  ::proto::Message_FutureProofMessage* _internal_mutable_ephemeralmessage();
+  public:
+  void unsafe_arena_set_allocated_ephemeralmessage(
+      ::proto::Message_FutureProofMessage* ephemeralmessage);
+  ::proto::Message_FutureProofMessage* unsafe_arena_release_ephemeralmessage();
+
+  // optional .proto.Message.InvoiceMessage invoiceMessage = 41;
+  bool has_invoicemessage() const;
+  private:
+  bool _internal_has_invoicemessage() const;
+  public:
+  void clear_invoicemessage();
+  const ::proto::Message_InvoiceMessage& invoicemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InvoiceMessage* release_invoicemessage();
+  ::proto::Message_InvoiceMessage* mutable_invoicemessage();
+  void set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage);
+  private:
+  const ::proto::Message_InvoiceMessage& _internal_invoicemessage() const;
+  ::proto::Message_InvoiceMessage* _internal_mutable_invoicemessage();
+  public:
+  void unsafe_arena_set_allocated_invoicemessage(
+      ::proto::Message_InvoiceMessage* invoicemessage);
+  ::proto::Message_InvoiceMessage* unsafe_arena_release_invoicemessage();
+
+  // optional .proto.Message.ButtonsMessage buttonsMessage = 42;
+  bool has_buttonsmessage() const;
+  private:
+  bool _internal_has_buttonsmessage() const;
+  public:
+  void clear_buttonsmessage();
+  const ::proto::Message_ButtonsMessage& buttonsmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage* release_buttonsmessage();
+  ::proto::Message_ButtonsMessage* mutable_buttonsmessage();
+  void set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage);
+  private:
+  const ::proto::Message_ButtonsMessage& _internal_buttonsmessage() const;
+  ::proto::Message_ButtonsMessage* _internal_mutable_buttonsmessage();
+  public:
+  void unsafe_arena_set_allocated_buttonsmessage(
+      ::proto::Message_ButtonsMessage* buttonsmessage);
+  ::proto::Message_ButtonsMessage* unsafe_arena_release_buttonsmessage();
+
+  // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
+  bool has_buttonsresponsemessage() const;
+  private:
+  bool _internal_has_buttonsresponsemessage() const;
+  public:
+  void clear_buttonsresponsemessage();
+  const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ButtonsResponseMessage* release_buttonsresponsemessage();
+  ::proto::Message_ButtonsResponseMessage* mutable_buttonsresponsemessage();
+  void set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage);
+  private:
+  const ::proto::Message_ButtonsResponseMessage& _internal_buttonsresponsemessage() const;
+  ::proto::Message_ButtonsResponseMessage* _internal_mutable_buttonsresponsemessage();
+  public:
+  void unsafe_arena_set_allocated_buttonsresponsemessage(
+      ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage);
+  ::proto::Message_ButtonsResponseMessage* unsafe_arena_release_buttonsresponsemessage();
+
+  // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
+  bool has_paymentinvitemessage() const;
+  private:
+  bool _internal_has_paymentinvitemessage() const;
+  public:
+  void clear_paymentinvitemessage();
+  const ::proto::Message_PaymentInviteMessage& paymentinvitemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_PaymentInviteMessage* release_paymentinvitemessage();
+  ::proto::Message_PaymentInviteMessage* mutable_paymentinvitemessage();
+  void set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage);
+  private:
+  const ::proto::Message_PaymentInviteMessage& _internal_paymentinvitemessage() const;
+  ::proto::Message_PaymentInviteMessage* _internal_mutable_paymentinvitemessage();
+  public:
+  void unsafe_arena_set_allocated_paymentinvitemessage(
+      ::proto::Message_PaymentInviteMessage* paymentinvitemessage);
+  ::proto::Message_PaymentInviteMessage* unsafe_arena_release_paymentinvitemessage();
+
+  // optional .proto.Message.InteractiveMessage interactiveMessage = 45;
+  bool has_interactivemessage() const;
+  private:
+  bool _internal_has_interactivemessage() const;
+  public:
+  void clear_interactivemessage();
+  const ::proto::Message_InteractiveMessage& interactivemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage* release_interactivemessage();
+  ::proto::Message_InteractiveMessage* mutable_interactivemessage();
+  void set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage);
+  private:
+  const ::proto::Message_InteractiveMessage& _internal_interactivemessage() const;
+  ::proto::Message_InteractiveMessage* _internal_mutable_interactivemessage();
+  public:
+  void unsafe_arena_set_allocated_interactivemessage(
+      ::proto::Message_InteractiveMessage* interactivemessage);
+  ::proto::Message_InteractiveMessage* unsafe_arena_release_interactivemessage();
+
+  // optional .proto.Message.ReactionMessage reactionMessage = 46;
+  bool has_reactionmessage() const;
+  private:
+  bool _internal_has_reactionmessage() const;
+  public:
+  void clear_reactionmessage();
+  const ::proto::Message_ReactionMessage& reactionmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_ReactionMessage* release_reactionmessage();
+  ::proto::Message_ReactionMessage* mutable_reactionmessage();
+  void set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage);
+  private:
+  const ::proto::Message_ReactionMessage& _internal_reactionmessage() const;
+  ::proto::Message_ReactionMessage* _internal_mutable_reactionmessage();
+  public:
+  void unsafe_arena_set_allocated_reactionmessage(
+      ::proto::Message_ReactionMessage* reactionmessage);
+  ::proto::Message_ReactionMessage* unsafe_arena_release_reactionmessage();
+
+  // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+  bool has_stickersyncrmrmessage() const;
+  private:
+  bool _internal_has_stickersyncrmrmessage() const;
+  public:
+  void clear_stickersyncrmrmessage();
+  const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_StickerSyncRMRMessage* release_stickersyncrmrmessage();
+  ::proto::Message_StickerSyncRMRMessage* mutable_stickersyncrmrmessage();
+  void set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage);
+  private:
+  const ::proto::Message_StickerSyncRMRMessage& _internal_stickersyncrmrmessage() const;
+  ::proto::Message_StickerSyncRMRMessage* _internal_mutable_stickersyncrmrmessage();
+  public:
+  void unsafe_arena_set_allocated_stickersyncrmrmessage(
+      ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage);
+  ::proto::Message_StickerSyncRMRMessage* unsafe_arena_release_stickersyncrmrmessage();
+
+  // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
+  bool has_interactiveresponsemessage() const;
+  private:
+  bool _internal_has_interactiveresponsemessage() const;
+  public:
+  void clear_interactiveresponsemessage();
+  const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage* release_interactiveresponsemessage();
+  ::proto::Message_InteractiveResponseMessage* mutable_interactiveresponsemessage();
+  void set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage);
+  private:
+  const ::proto::Message_InteractiveResponseMessage& _internal_interactiveresponsemessage() const;
+  ::proto::Message_InteractiveResponseMessage* _internal_mutable_interactiveresponsemessage();
+  public:
+  void unsafe_arena_set_allocated_interactiveresponsemessage(
+      ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage);
+  ::proto::Message_InteractiveResponseMessage* unsafe_arena_release_interactiveresponsemessage();
+
+  // optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
+  bool has_pollcreationmessage() const;
+  private:
+  bool _internal_has_pollcreationmessage() const;
+  public:
+  void clear_pollcreationmessage();
+  const ::proto::Message_PollCreationMessage& pollcreationmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_PollCreationMessage* release_pollcreationmessage();
+  ::proto::Message_PollCreationMessage* mutable_pollcreationmessage();
+  void set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage);
+  private:
+  const ::proto::Message_PollCreationMessage& _internal_pollcreationmessage() const;
+  ::proto::Message_PollCreationMessage* _internal_mutable_pollcreationmessage();
+  public:
+  void unsafe_arena_set_allocated_pollcreationmessage(
+      ::proto::Message_PollCreationMessage* pollcreationmessage);
+  ::proto::Message_PollCreationMessage* unsafe_arena_release_pollcreationmessage();
+
+  // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
+  bool has_pollupdatemessage() const;
+  private:
+  bool _internal_has_pollupdatemessage() const;
+  public:
+  void clear_pollupdatemessage();
+  const ::proto::Message_PollUpdateMessage& pollupdatemessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessage* release_pollupdatemessage();
+  ::proto::Message_PollUpdateMessage* mutable_pollupdatemessage();
+  void set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage);
+  private:
+  const ::proto::Message_PollUpdateMessage& _internal_pollupdatemessage() const;
+  ::proto::Message_PollUpdateMessage* _internal_mutable_pollupdatemessage();
+  public:
+  void unsafe_arena_set_allocated_pollupdatemessage(
+      ::proto::Message_PollUpdateMessage* pollupdatemessage);
+  ::proto::Message_PollUpdateMessage* unsafe_arena_release_pollupdatemessage();
+
+  // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
+  bool has_keepinchatmessage() const;
+  private:
+  bool _internal_has_keepinchatmessage() const;
+  public:
+  void clear_keepinchatmessage();
+  const ::proto::Message_KeepInChatMessage& keepinchatmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_KeepInChatMessage* release_keepinchatmessage();
+  ::proto::Message_KeepInChatMessage* mutable_keepinchatmessage();
+  void set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage);
+  private:
+  const ::proto::Message_KeepInChatMessage& _internal_keepinchatmessage() const;
+  ::proto::Message_KeepInChatMessage* _internal_mutable_keepinchatmessage();
+  public:
+  void unsafe_arena_set_allocated_keepinchatmessage(
+      ::proto::Message_KeepInChatMessage* keepinchatmessage);
+  ::proto::Message_KeepInChatMessage* unsafe_arena_release_keepinchatmessage();
+
+  // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
+  bool has_documentwithcaptionmessage() const;
+  private:
+  bool _internal_has_documentwithcaptionmessage() const;
+  public:
+  void clear_documentwithcaptionmessage();
+  const ::proto::Message_FutureProofMessage& documentwithcaptionmessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_documentwithcaptionmessage();
+  ::proto::Message_FutureProofMessage* mutable_documentwithcaptionmessage();
+  void set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage);
+  private:
+  const ::proto::Message_FutureProofMessage& _internal_documentwithcaptionmessage() const;
+  ::proto::Message_FutureProofMessage* _internal_mutable_documentwithcaptionmessage();
+  public:
+  void unsafe_arena_set_allocated_documentwithcaptionmessage(
+      ::proto::Message_FutureProofMessage* documentwithcaptionmessage);
+  ::proto::Message_FutureProofMessage* unsafe_arena_release_documentwithcaptionmessage();
+
+  // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+  bool has_requestphonenumbermessage() const;
+  private:
+  bool _internal_has_requestphonenumbermessage() const;
+  public:
+  void clear_requestphonenumbermessage();
+  const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage() const;
+  PROTOBUF_NODISCARD ::proto::Message_RequestPhoneNumberMessage* release_requestphonenumbermessage();
+  ::proto::Message_RequestPhoneNumberMessage* mutable_requestphonenumbermessage();
+  void set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage);
+  private:
+  const ::proto::Message_RequestPhoneNumberMessage& _internal_requestphonenumbermessage() const;
+  ::proto::Message_RequestPhoneNumberMessage* _internal_mutable_requestphonenumbermessage();
+  public:
+  void unsafe_arena_set_allocated_requestphonenumbermessage(
+      ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage);
+  ::proto::Message_RequestPhoneNumberMessage* unsafe_arena_release_requestphonenumbermessage();
+
+  // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
+  bool has_viewoncemessagev2() const;
+  private:
+  bool _internal_has_viewoncemessagev2() const;
+  public:
+  void clear_viewoncemessagev2();
+  const ::proto::Message_FutureProofMessage& viewoncemessagev2() const;
+  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessagev2();
+  ::proto::Message_FutureProofMessage* mutable_viewoncemessagev2();
+  void set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2);
+  private:
+  const ::proto::Message_FutureProofMessage& _internal_viewoncemessagev2() const;
+  ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessagev2();
+  public:
+  void unsafe_arena_set_allocated_viewoncemessagev2(
+      ::proto::Message_FutureProofMessage* viewoncemessagev2);
+  ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessagev2();
+
+  // @@protoc_insertion_point(class_scope:proto.Message)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversation_;
+    ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage_;
+    ::proto::Message_ImageMessage* imagemessage_;
+    ::proto::Message_ContactMessage* contactmessage_;
+    ::proto::Message_LocationMessage* locationmessage_;
+    ::proto::Message_ExtendedTextMessage* extendedtextmessage_;
+    ::proto::Message_DocumentMessage* documentmessage_;
+    ::proto::Message_AudioMessage* audiomessage_;
+    ::proto::Message_VideoMessage* videomessage_;
+    ::proto::Message_Call* call_;
+    ::proto::Message_Chat* chat_;
+    ::proto::Message_ProtocolMessage* protocolmessage_;
+    ::proto::Message_ContactsArrayMessage* contactsarraymessage_;
+    ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_;
+    ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage_;
+    ::proto::Message_SendPaymentMessage* sendpaymentmessage_;
+    ::proto::Message_LiveLocationMessage* livelocationmessage_;
+    ::proto::Message_RequestPaymentMessage* requestpaymentmessage_;
+    ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage_;
+    ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage_;
+    ::proto::Message_TemplateMessage* templatemessage_;
+    ::proto::Message_StickerMessage* stickermessage_;
+    ::proto::Message_GroupInviteMessage* groupinvitemessage_;
+    ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage_;
+    ::proto::Message_ProductMessage* productmessage_;
+    ::proto::Message_DeviceSentMessage* devicesentmessage_;
+    ::proto::MessageContextInfo* messagecontextinfo_;
+    ::proto::Message_ListMessage* listmessage_;
+    ::proto::Message_FutureProofMessage* viewoncemessage_;
+    ::proto::Message_OrderMessage* ordermessage_;
+    ::proto::Message_ListResponseMessage* listresponsemessage_;
+    ::proto::Message_FutureProofMessage* ephemeralmessage_;
+    ::proto::Message_InvoiceMessage* invoicemessage_;
+    ::proto::Message_ButtonsMessage* buttonsmessage_;
+    ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage_;
+    ::proto::Message_PaymentInviteMessage* paymentinvitemessage_;
+    ::proto::Message_InteractiveMessage* interactivemessage_;
+    ::proto::Message_ReactionMessage* reactionmessage_;
+    ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage_;
+    ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage_;
+    ::proto::Message_PollCreationMessage* pollcreationmessage_;
+    ::proto::Message_PollUpdateMessage* pollupdatemessage_;
+    ::proto::Message_KeepInChatMessage* keepinchatmessage_;
+    ::proto::Message_FutureProofMessage* documentwithcaptionmessage_;
+    ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage_;
+    ::proto::Message_FutureProofMessage* viewoncemessagev2_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MessageContextInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageContextInfo) */ {
+ public:
+  inline MessageContextInfo() : MessageContextInfo(nullptr) {}
+  ~MessageContextInfo() override;
+  explicit PROTOBUF_CONSTEXPR MessageContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MessageContextInfo(const MessageContextInfo& from);
+  MessageContextInfo(MessageContextInfo&& from) noexcept
+    : MessageContextInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageContextInfo& operator=(const MessageContextInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MessageContextInfo& operator=(MessageContextInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MessageContextInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MessageContextInfo* internal_default_instance() {
+    return reinterpret_cast<const MessageContextInfo*>(
+               &_MessageContextInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    138;
+
+  friend void swap(MessageContextInfo& a, MessageContextInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MessageContextInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MessageContextInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MessageContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MessageContextInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MessageContextInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MessageContextInfo& from) {
+    MessageContextInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MessageContextInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MessageContextInfo";
+  }
+  protected:
+  explicit MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageSecretFieldNumber = 3,
+    kPaddingBytesFieldNumber = 4,
+    kDeviceListMetadataFieldNumber = 1,
+    kDeviceListMetadataVersionFieldNumber = 2,
+  };
+  // optional bytes messageSecret = 3;
+  bool has_messagesecret() const;
+  private:
+  bool _internal_has_messagesecret() const;
+  public:
+  void clear_messagesecret();
+  const std::string& messagesecret() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_messagesecret(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_messagesecret();
+  PROTOBUF_NODISCARD std::string* release_messagesecret();
+  void set_allocated_messagesecret(std::string* messagesecret);
+  private:
+  const std::string& _internal_messagesecret() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
+  std::string* _internal_mutable_messagesecret();
+  public:
+
+  // optional bytes paddingBytes = 4;
+  bool has_paddingbytes() const;
+  private:
+  bool _internal_has_paddingbytes() const;
+  public:
+  void clear_paddingbytes();
+  const std::string& paddingbytes() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_paddingbytes(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_paddingbytes();
+  PROTOBUF_NODISCARD std::string* release_paddingbytes();
+  void set_allocated_paddingbytes(std::string* paddingbytes);
+  private:
+  const std::string& _internal_paddingbytes() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value);
+  std::string* _internal_mutable_paddingbytes();
+  public:
+
+  // optional .proto.DeviceListMetadata deviceListMetadata = 1;
+  bool has_devicelistmetadata() const;
+  private:
+  bool _internal_has_devicelistmetadata() const;
+  public:
+  void clear_devicelistmetadata();
+  const ::proto::DeviceListMetadata& devicelistmetadata() const;
+  PROTOBUF_NODISCARD ::proto::DeviceListMetadata* release_devicelistmetadata();
+  ::proto::DeviceListMetadata* mutable_devicelistmetadata();
+  void set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata);
+  private:
+  const ::proto::DeviceListMetadata& _internal_devicelistmetadata() const;
+  ::proto::DeviceListMetadata* _internal_mutable_devicelistmetadata();
+  public:
+  void unsafe_arena_set_allocated_devicelistmetadata(
+      ::proto::DeviceListMetadata* devicelistmetadata);
+  ::proto::DeviceListMetadata* unsafe_arena_release_devicelistmetadata();
+
+  // optional int32 deviceListMetadataVersion = 2;
+  bool has_devicelistmetadataversion() const;
+  private:
+  bool _internal_has_devicelistmetadataversion() const;
+  public:
+  void clear_devicelistmetadataversion();
+  int32_t devicelistmetadataversion() const;
+  void set_devicelistmetadataversion(int32_t value);
+  private:
+  int32_t _internal_devicelistmetadataversion() const;
+  void _internal_set_devicelistmetadataversion(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MessageContextInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_;
+    ::proto::DeviceListMetadata* devicelistmetadata_;
+    int32_t devicelistmetadataversion_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MessageKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageKey) */ {
+ public:
+  inline MessageKey() : MessageKey(nullptr) {}
+  ~MessageKey() override;
+  explicit PROTOBUF_CONSTEXPR MessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MessageKey(const MessageKey& from);
+  MessageKey(MessageKey&& from) noexcept
+    : MessageKey() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageKey& operator=(const MessageKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MessageKey& operator=(MessageKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MessageKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MessageKey* internal_default_instance() {
+    return reinterpret_cast<const MessageKey*>(
+               &_MessageKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    139;
+
+  friend void swap(MessageKey& a, MessageKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MessageKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MessageKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MessageKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MessageKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MessageKey& from) {
+    MessageKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MessageKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MessageKey";
+  }
+  protected:
+  explicit MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRemoteJidFieldNumber = 1,
+    kIdFieldNumber = 3,
+    kParticipantFieldNumber = 4,
+    kFromMeFieldNumber = 2,
+  };
+  // optional string remoteJid = 1;
+  bool has_remotejid() const;
+  private:
+  bool _internal_has_remotejid() const;
+  public:
+  void clear_remotejid();
+  const std::string& remotejid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remotejid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remotejid();
+  PROTOBUF_NODISCARD std::string* release_remotejid();
+  void set_allocated_remotejid(std::string* remotejid);
+  private:
+  const std::string& _internal_remotejid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value);
+  std::string* _internal_mutable_remotejid();
+  public:
+
+  // optional string id = 3;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional string participant = 4;
+  bool has_participant() const;
+  private:
+  bool _internal_has_participant() const;
+  public:
+  void clear_participant();
+  const std::string& participant() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_participant(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_participant();
+  PROTOBUF_NODISCARD std::string* release_participant();
+  void set_allocated_participant(std::string* participant);
+  private:
+  const std::string& _internal_participant() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
+  std::string* _internal_mutable_participant();
+  public:
+
+  // optional bool fromMe = 2;
+  bool has_fromme() const;
+  private:
+  bool _internal_has_fromme() const;
+  public:
+  void clear_fromme();
+  bool fromme() const;
+  void set_fromme(bool value);
+  private:
+  bool _internal_fromme() const;
+  void _internal_set_fromme(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MessageKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
+    bool fromme_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Money final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Money) */ {
+ public:
+  inline Money() : Money(nullptr) {}
+  ~Money() override;
+  explicit PROTOBUF_CONSTEXPR Money(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Money(const Money& from);
+  Money(Money&& from) noexcept
+    : Money() {
+    *this = ::std::move(from);
+  }
+
+  inline Money& operator=(const Money& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Money& operator=(Money&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Money& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Money* internal_default_instance() {
+    return reinterpret_cast<const Money*>(
+               &_Money_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    140;
+
+  friend void swap(Money& a, Money& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Money* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Money* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Money* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Money>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Money& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Money& from) {
+    Money::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Money* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Money";
+  }
+  protected:
+  explicit Money(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCurrencyCodeFieldNumber = 3,
+    kValueFieldNumber = 1,
+    kOffsetFieldNumber = 2,
+  };
+  // optional string currencyCode = 3;
+  bool has_currencycode() const;
+  private:
+  bool _internal_has_currencycode() const;
+  public:
+  void clear_currencycode();
+  const std::string& currencycode() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_currencycode(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_currencycode();
+  PROTOBUF_NODISCARD std::string* release_currencycode();
+  void set_allocated_currencycode(std::string* currencycode);
+  private:
+  const std::string& _internal_currencycode() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
+  std::string* _internal_mutable_currencycode();
+  public:
+
+  // optional int64 value = 1;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  int64_t value() const;
+  void set_value(int64_t value);
+  private:
+  int64_t _internal_value() const;
+  void _internal_set_value(int64_t value);
+  public:
+
+  // optional uint32 offset = 2;
+  bool has_offset() const;
+  private:
+  bool _internal_has_offset() const;
+  public:
+  void clear_offset();
+  uint32_t offset() const;
+  void set_offset(uint32_t value);
+  private:
+  uint32_t _internal_offset() const;
+  void _internal_set_offset(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Money)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_;
+    int64_t value_;
+    uint32_t offset_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgOpaqueData_PollOption final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData.PollOption) */ {
+ public:
+  inline MsgOpaqueData_PollOption() : MsgOpaqueData_PollOption(nullptr) {}
+  ~MsgOpaqueData_PollOption() override;
+  explicit PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from);
+  MsgOpaqueData_PollOption(MsgOpaqueData_PollOption&& from) noexcept
+    : MsgOpaqueData_PollOption() {
+    *this = ::std::move(from);
+  }
+
+  inline MsgOpaqueData_PollOption& operator=(const MsgOpaqueData_PollOption& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MsgOpaqueData_PollOption& operator=(MsgOpaqueData_PollOption&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MsgOpaqueData_PollOption& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MsgOpaqueData_PollOption* internal_default_instance() {
+    return reinterpret_cast<const MsgOpaqueData_PollOption*>(
+               &_MsgOpaqueData_PollOption_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    141;
+
+  friend void swap(MsgOpaqueData_PollOption& a, MsgOpaqueData_PollOption& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MsgOpaqueData_PollOption* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MsgOpaqueData_PollOption* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MsgOpaqueData_PollOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MsgOpaqueData_PollOption>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MsgOpaqueData_PollOption& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MsgOpaqueData_PollOption& from) {
+    MsgOpaqueData_PollOption::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MsgOpaqueData_PollOption* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MsgOpaqueData.PollOption";
+  }
+  protected:
+  explicit MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData.PollOption)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgOpaqueData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData) */ {
+ public:
+  inline MsgOpaqueData() : MsgOpaqueData(nullptr) {}
+  ~MsgOpaqueData() override;
+  explicit PROTOBUF_CONSTEXPR MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MsgOpaqueData(const MsgOpaqueData& from);
+  MsgOpaqueData(MsgOpaqueData&& from) noexcept
+    : MsgOpaqueData() {
+    *this = ::std::move(from);
+  }
+
+  inline MsgOpaqueData& operator=(const MsgOpaqueData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MsgOpaqueData& operator=(MsgOpaqueData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MsgOpaqueData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MsgOpaqueData* internal_default_instance() {
+    return reinterpret_cast<const MsgOpaqueData*>(
+               &_MsgOpaqueData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    142;
+
+  friend void swap(MsgOpaqueData& a, MsgOpaqueData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MsgOpaqueData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MsgOpaqueData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MsgOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MsgOpaqueData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MsgOpaqueData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MsgOpaqueData& from) {
+    MsgOpaqueData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MsgOpaqueData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MsgOpaqueData";
+  }
+  protected:
+  explicit MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MsgOpaqueData_PollOption PollOption;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPollOptionsFieldNumber = 18,
+    kBodyFieldNumber = 1,
+    kCaptionFieldNumber = 3,
+    kPaymentNoteMsgBodyFieldNumber = 9,
+    kCanonicalUrlFieldNumber = 10,
+    kMatchedTextFieldNumber = 11,
+    kTitleFieldNumber = 12,
+    kDescriptionFieldNumber = 13,
+    kFutureproofBufferFieldNumber = 14,
+    kClientUrlFieldNumber = 15,
+    kLocFieldNumber = 16,
+    kPollNameFieldNumber = 17,
+    kMessageSecretFieldNumber = 21,
+    kPollUpdateParentKeyFieldNumber = 23,
+    kEncPollVoteFieldNumber = 24,
+    kLngFieldNumber = 5,
+    kLatFieldNumber = 7,
+    kIsLiveFieldNumber = 6,
+    kPaymentAmount1000FieldNumber = 8,
+    kSenderTimestampMsFieldNumber = 22,
+    kPollSelectableOptionsCountFieldNumber = 20,
+  };
+  // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
+  int polloptions_size() const;
+  private:
+  int _internal_polloptions_size() const;
+  public:
+  void clear_polloptions();
+  ::proto::MsgOpaqueData_PollOption* mutable_polloptions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >*
+      mutable_polloptions();
+  private:
+  const ::proto::MsgOpaqueData_PollOption& _internal_polloptions(int index) const;
+  ::proto::MsgOpaqueData_PollOption* _internal_add_polloptions();
+  public:
+  const ::proto::MsgOpaqueData_PollOption& polloptions(int index) const;
+  ::proto::MsgOpaqueData_PollOption* add_polloptions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >&
+      polloptions() const;
+
+  // optional string body = 1;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // optional string caption = 3;
+  bool has_caption() const;
+  private:
+  bool _internal_has_caption() const;
+  public:
+  void clear_caption();
+  const std::string& caption() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_caption(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_caption();
+  PROTOBUF_NODISCARD std::string* release_caption();
+  void set_allocated_caption(std::string* caption);
+  private:
+  const std::string& _internal_caption() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value);
+  std::string* _internal_mutable_caption();
+  public:
+
+  // optional string paymentNoteMsgBody = 9;
+  bool has_paymentnotemsgbody() const;
+  private:
+  bool _internal_has_paymentnotemsgbody() const;
+  public:
+  void clear_paymentnotemsgbody();
+  const std::string& paymentnotemsgbody() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_paymentnotemsgbody();
+  PROTOBUF_NODISCARD std::string* release_paymentnotemsgbody();
+  void set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody);
+  private:
+  const std::string& _internal_paymentnotemsgbody() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paymentnotemsgbody(const std::string& value);
+  std::string* _internal_mutable_paymentnotemsgbody();
+  public:
+
+  // optional string canonicalUrl = 10;
+  bool has_canonicalurl() const;
+  private:
+  bool _internal_has_canonicalurl() const;
+  public:
+  void clear_canonicalurl();
+  const std::string& canonicalurl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_canonicalurl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_canonicalurl();
+  PROTOBUF_NODISCARD std::string* release_canonicalurl();
+  void set_allocated_canonicalurl(std::string* canonicalurl);
+  private:
+  const std::string& _internal_canonicalurl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value);
+  std::string* _internal_mutable_canonicalurl();
+  public:
+
+  // optional string matchedText = 11;
+  bool has_matchedtext() const;
+  private:
+  bool _internal_has_matchedtext() const;
+  public:
+  void clear_matchedtext();
+  const std::string& matchedtext() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_matchedtext(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_matchedtext();
+  PROTOBUF_NODISCARD std::string* release_matchedtext();
+  void set_allocated_matchedtext(std::string* matchedtext);
+  private:
+  const std::string& _internal_matchedtext() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value);
+  std::string* _internal_mutable_matchedtext();
+  public:
+
+  // optional string title = 12;
+  bool has_title() const;
+  private:
+  bool _internal_has_title() const;
+  public:
+  void clear_title();
+  const std::string& title() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_title(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_title();
+  PROTOBUF_NODISCARD std::string* release_title();
+  void set_allocated_title(std::string* title);
+  private:
+  const std::string& _internal_title() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
+  std::string* _internal_mutable_title();
+  public:
+
+  // optional string description = 13;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional bytes futureproofBuffer = 14;
+  bool has_futureproofbuffer() const;
+  private:
+  bool _internal_has_futureproofbuffer() const;
+  public:
+  void clear_futureproofbuffer();
+  const std::string& futureproofbuffer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_futureproofbuffer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_futureproofbuffer();
+  PROTOBUF_NODISCARD std::string* release_futureproofbuffer();
+  void set_allocated_futureproofbuffer(std::string* futureproofbuffer);
+  private:
+  const std::string& _internal_futureproofbuffer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofbuffer(const std::string& value);
+  std::string* _internal_mutable_futureproofbuffer();
+  public:
+
+  // optional string clientUrl = 15;
+  bool has_clienturl() const;
+  private:
+  bool _internal_has_clienturl() const;
+  public:
+  void clear_clienturl();
+  const std::string& clienturl() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_clienturl(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_clienturl();
+  PROTOBUF_NODISCARD std::string* release_clienturl();
+  void set_allocated_clienturl(std::string* clienturl);
+  private:
+  const std::string& _internal_clienturl() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_clienturl(const std::string& value);
+  std::string* _internal_mutable_clienturl();
+  public:
+
+  // optional string loc = 16;
+  bool has_loc() const;
+  private:
+  bool _internal_has_loc() const;
+  public:
+  void clear_loc();
+  const std::string& loc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_loc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_loc();
+  PROTOBUF_NODISCARD std::string* release_loc();
+  void set_allocated_loc(std::string* loc);
+  private:
+  const std::string& _internal_loc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_loc(const std::string& value);
+  std::string* _internal_mutable_loc();
+  public:
+
+  // optional string pollName = 17;
+  bool has_pollname() const;
+  private:
+  bool _internal_has_pollname() const;
+  public:
+  void clear_pollname();
+  const std::string& pollname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pollname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pollname();
+  PROTOBUF_NODISCARD std::string* release_pollname();
+  void set_allocated_pollname(std::string* pollname);
+  private:
+  const std::string& _internal_pollname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollname(const std::string& value);
+  std::string* _internal_mutable_pollname();
+  public:
+
+  // optional bytes messageSecret = 21;
+  bool has_messagesecret() const;
+  private:
+  bool _internal_has_messagesecret() const;
+  public:
+  void clear_messagesecret();
+  const std::string& messagesecret() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_messagesecret(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_messagesecret();
+  PROTOBUF_NODISCARD std::string* release_messagesecret();
+  void set_allocated_messagesecret(std::string* messagesecret);
+  private:
+  const std::string& _internal_messagesecret() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
+  std::string* _internal_mutable_messagesecret();
+  public:
+
+  // optional string pollUpdateParentKey = 23;
+  bool has_pollupdateparentkey() const;
+  private:
+  bool _internal_has_pollupdateparentkey() const;
+  public:
+  void clear_pollupdateparentkey();
+  const std::string& pollupdateparentkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pollupdateparentkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pollupdateparentkey();
+  PROTOBUF_NODISCARD std::string* release_pollupdateparentkey();
+  void set_allocated_pollupdateparentkey(std::string* pollupdateparentkey);
+  private:
+  const std::string& _internal_pollupdateparentkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollupdateparentkey(const std::string& value);
+  std::string* _internal_mutable_pollupdateparentkey();
+  public:
+
+  // optional .proto.PollEncValue encPollVote = 24;
+  bool has_encpollvote() const;
+  private:
+  bool _internal_has_encpollvote() const;
+  public:
+  void clear_encpollvote();
+  const ::proto::PollEncValue& encpollvote() const;
+  PROTOBUF_NODISCARD ::proto::PollEncValue* release_encpollvote();
+  ::proto::PollEncValue* mutable_encpollvote();
+  void set_allocated_encpollvote(::proto::PollEncValue* encpollvote);
+  private:
+  const ::proto::PollEncValue& _internal_encpollvote() const;
+  ::proto::PollEncValue* _internal_mutable_encpollvote();
+  public:
+  void unsafe_arena_set_allocated_encpollvote(
+      ::proto::PollEncValue* encpollvote);
+  ::proto::PollEncValue* unsafe_arena_release_encpollvote();
+
+  // optional double lng = 5;
+  bool has_lng() const;
+  private:
+  bool _internal_has_lng() const;
+  public:
+  void clear_lng();
+  double lng() const;
+  void set_lng(double value);
+  private:
+  double _internal_lng() const;
+  void _internal_set_lng(double value);
+  public:
+
+  // optional double lat = 7;
+  bool has_lat() const;
+  private:
+  bool _internal_has_lat() const;
+  public:
+  void clear_lat();
+  double lat() const;
+  void set_lat(double value);
+  private:
+  double _internal_lat() const;
+  void _internal_set_lat(double value);
+  public:
+
+  // optional bool isLive = 6;
+  bool has_islive() const;
+  private:
+  bool _internal_has_islive() const;
+  public:
+  void clear_islive();
+  bool islive() const;
+  void set_islive(bool value);
+  private:
+  bool _internal_islive() const;
+  void _internal_set_islive(bool value);
+  public:
+
+  // optional int32 paymentAmount1000 = 8;
+  bool has_paymentamount1000() const;
+  private:
+  bool _internal_has_paymentamount1000() const;
+  public:
+  void clear_paymentamount1000();
+  int32_t paymentamount1000() const;
+  void set_paymentamount1000(int32_t value);
+  private:
+  int32_t _internal_paymentamount1000() const;
+  void _internal_set_paymentamount1000(int32_t value);
+  public:
+
+  // optional int64 senderTimestampMs = 22;
+  bool has_sendertimestampms() const;
+  private:
+  bool _internal_has_sendertimestampms() const;
+  public:
+  void clear_sendertimestampms();
+  int64_t sendertimestampms() const;
+  void set_sendertimestampms(int64_t value);
+  private:
+  int64_t _internal_sendertimestampms() const;
+  void _internal_set_sendertimestampms(int64_t value);
+  public:
+
+  // optional uint32 pollSelectableOptionsCount = 20;
+  bool has_pollselectableoptionscount() const;
+  private:
+  bool _internal_has_pollselectableoptionscount() const;
+  public:
+  void clear_pollselectableoptionscount();
+  uint32_t pollselectableoptionscount() const;
+  void set_pollselectableoptionscount(uint32_t value);
+  private:
+  uint32_t _internal_pollselectableoptionscount() const;
+  void _internal_set_pollselectableoptionscount(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption > polloptions_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paymentnotemsgbody_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofbuffer_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clienturl_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loc_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollupdateparentkey_;
+    ::proto::PollEncValue* encpollvote_;
+    double lng_;
+    double lat_;
+    bool islive_;
+    int32_t paymentamount1000_;
+    int64_t sendertimestampms_;
+    uint32_t pollselectableoptionscount_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRowOpaqueData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgRowOpaqueData) */ {
+ public:
+  inline MsgRowOpaqueData() : MsgRowOpaqueData(nullptr) {}
+  ~MsgRowOpaqueData() override;
+  explicit PROTOBUF_CONSTEXPR MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MsgRowOpaqueData(const MsgRowOpaqueData& from);
+  MsgRowOpaqueData(MsgRowOpaqueData&& from) noexcept
+    : MsgRowOpaqueData() {
+    *this = ::std::move(from);
+  }
+
+  inline MsgRowOpaqueData& operator=(const MsgRowOpaqueData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MsgRowOpaqueData& operator=(MsgRowOpaqueData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MsgRowOpaqueData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MsgRowOpaqueData* internal_default_instance() {
+    return reinterpret_cast<const MsgRowOpaqueData*>(
+               &_MsgRowOpaqueData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    143;
+
+  friend void swap(MsgRowOpaqueData& a, MsgRowOpaqueData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MsgRowOpaqueData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MsgRowOpaqueData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MsgRowOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MsgRowOpaqueData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MsgRowOpaqueData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MsgRowOpaqueData& from) {
+    MsgRowOpaqueData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MsgRowOpaqueData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.MsgRowOpaqueData";
+  }
+  protected:
+  explicit MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCurrentMsgFieldNumber = 1,
+    kQuotedMsgFieldNumber = 2,
+  };
+  // optional .proto.MsgOpaqueData currentMsg = 1;
+  bool has_currentmsg() const;
+  private:
+  bool _internal_has_currentmsg() const;
+  public:
+  void clear_currentmsg();
+  const ::proto::MsgOpaqueData& currentmsg() const;
+  PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_currentmsg();
+  ::proto::MsgOpaqueData* mutable_currentmsg();
+  void set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg);
+  private:
+  const ::proto::MsgOpaqueData& _internal_currentmsg() const;
+  ::proto::MsgOpaqueData* _internal_mutable_currentmsg();
+  public:
+  void unsafe_arena_set_allocated_currentmsg(
+      ::proto::MsgOpaqueData* currentmsg);
+  ::proto::MsgOpaqueData* unsafe_arena_release_currentmsg();
+
+  // optional .proto.MsgOpaqueData quotedMsg = 2;
+  bool has_quotedmsg() const;
+  private:
+  bool _internal_has_quotedmsg() const;
+  public:
+  void clear_quotedmsg();
+  const ::proto::MsgOpaqueData& quotedmsg() const;
+  PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_quotedmsg();
+  ::proto::MsgOpaqueData* mutable_quotedmsg();
+  void set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg);
+  private:
+  const ::proto::MsgOpaqueData& _internal_quotedmsg() const;
+  ::proto::MsgOpaqueData* _internal_mutable_quotedmsg();
+  public:
+  void unsafe_arena_set_allocated_quotedmsg(
+      ::proto::MsgOpaqueData* quotedmsg);
+  ::proto::MsgOpaqueData* unsafe_arena_release_quotedmsg();
+
+  // @@protoc_insertion_point(class_scope:proto.MsgRowOpaqueData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MsgOpaqueData* currentmsg_;
+    ::proto::MsgOpaqueData* quotedmsg_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NoiseCertificate_Details final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate.Details) */ {
+ public:
+  inline NoiseCertificate_Details() : NoiseCertificate_Details(nullptr) {}
+  ~NoiseCertificate_Details() override;
+  explicit PROTOBUF_CONSTEXPR NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NoiseCertificate_Details(const NoiseCertificate_Details& from);
+  NoiseCertificate_Details(NoiseCertificate_Details&& from) noexcept
+    : NoiseCertificate_Details() {
+    *this = ::std::move(from);
+  }
+
+  inline NoiseCertificate_Details& operator=(const NoiseCertificate_Details& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NoiseCertificate_Details& operator=(NoiseCertificate_Details&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NoiseCertificate_Details& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NoiseCertificate_Details* internal_default_instance() {
+    return reinterpret_cast<const NoiseCertificate_Details*>(
+               &_NoiseCertificate_Details_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    144;
+
+  friend void swap(NoiseCertificate_Details& a, NoiseCertificate_Details& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NoiseCertificate_Details* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NoiseCertificate_Details* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NoiseCertificate_Details>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NoiseCertificate_Details& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NoiseCertificate_Details& from) {
+    NoiseCertificate_Details::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NoiseCertificate_Details* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.NoiseCertificate.Details";
+  }
+  protected:
+  explicit NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIssuerFieldNumber = 2,
+    kSubjectFieldNumber = 4,
+    kKeyFieldNumber = 5,
+    kExpiresFieldNumber = 3,
+    kSerialFieldNumber = 1,
+  };
+  // optional string issuer = 2;
+  bool has_issuer() const;
+  private:
+  bool _internal_has_issuer() const;
+  public:
+  void clear_issuer();
+  const std::string& issuer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_issuer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_issuer();
+  PROTOBUF_NODISCARD std::string* release_issuer();
+  void set_allocated_issuer(std::string* issuer);
+  private:
+  const std::string& _internal_issuer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value);
+  std::string* _internal_mutable_issuer();
+  public:
+
+  // optional string subject = 4;
+  bool has_subject() const;
+  private:
+  bool _internal_has_subject() const;
+  public:
+  void clear_subject();
+  const std::string& subject() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_subject(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_subject();
+  PROTOBUF_NODISCARD std::string* release_subject();
+  void set_allocated_subject(std::string* subject);
+  private:
+  const std::string& _internal_subject() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject(const std::string& value);
+  std::string* _internal_mutable_subject();
+  public:
+
+  // optional bytes key = 5;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_NODISCARD std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional uint64 expires = 3;
+  bool has_expires() const;
+  private:
+  bool _internal_has_expires() const;
+  public:
+  void clear_expires();
+  uint64_t expires() const;
+  void set_expires(uint64_t value);
+  private:
+  uint64_t _internal_expires() const;
+  void _internal_set_expires(uint64_t value);
+  public:
+
+  // optional uint32 serial = 1;
+  bool has_serial() const;
+  private:
+  bool _internal_has_serial() const;
+  public:
+  void clear_serial();
+  uint32_t serial() const;
+  void set_serial(uint32_t value);
+  private:
+  uint32_t _internal_serial() const;
+  void _internal_set_serial(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.NoiseCertificate.Details)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subject_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+    uint64_t expires_;
+    uint32_t serial_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NoiseCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate) */ {
+ public:
+  inline NoiseCertificate() : NoiseCertificate(nullptr) {}
+  ~NoiseCertificate() override;
+  explicit PROTOBUF_CONSTEXPR NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NoiseCertificate(const NoiseCertificate& from);
+  NoiseCertificate(NoiseCertificate&& from) noexcept
+    : NoiseCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline NoiseCertificate& operator=(const NoiseCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NoiseCertificate& operator=(NoiseCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NoiseCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NoiseCertificate* internal_default_instance() {
+    return reinterpret_cast<const NoiseCertificate*>(
+               &_NoiseCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    145;
+
+  friend void swap(NoiseCertificate& a, NoiseCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NoiseCertificate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NoiseCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NoiseCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NoiseCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NoiseCertificate& from) {
+    NoiseCertificate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NoiseCertificate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.NoiseCertificate";
+  }
+  protected:
+  explicit NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef NoiseCertificate_Details Details;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_NODISCARD std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.NoiseCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NotificationMessageInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NotificationMessageInfo) */ {
+ public:
+  inline NotificationMessageInfo() : NotificationMessageInfo(nullptr) {}
+  ~NotificationMessageInfo() override;
+  explicit PROTOBUF_CONSTEXPR NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NotificationMessageInfo(const NotificationMessageInfo& from);
+  NotificationMessageInfo(NotificationMessageInfo&& from) noexcept
+    : NotificationMessageInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline NotificationMessageInfo& operator=(const NotificationMessageInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NotificationMessageInfo& operator=(NotificationMessageInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NotificationMessageInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NotificationMessageInfo* internal_default_instance() {
+    return reinterpret_cast<const NotificationMessageInfo*>(
+               &_NotificationMessageInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    146;
+
+  friend void swap(NotificationMessageInfo& a, NotificationMessageInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NotificationMessageInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NotificationMessageInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NotificationMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NotificationMessageInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NotificationMessageInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NotificationMessageInfo& from) {
+    NotificationMessageInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NotificationMessageInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.NotificationMessageInfo";
+  }
+  protected:
+  explicit NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kParticipantFieldNumber = 4,
+    kKeyFieldNumber = 1,
+    kMessageFieldNumber = 2,
+    kMessageTimestampFieldNumber = 3,
+  };
+  // optional string participant = 4;
+  bool has_participant() const;
+  private:
+  bool _internal_has_participant() const;
+  public:
+  void clear_participant();
+  const std::string& participant() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_participant(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_participant();
+  PROTOBUF_NODISCARD std::string* release_participant();
+  void set_allocated_participant(std::string* participant);
+  private:
+  const std::string& _internal_participant() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
+  std::string* _internal_mutable_participant();
+  public:
+
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional .proto.Message message = 2;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const ::proto::Message& message() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_message();
+  ::proto::Message* mutable_message();
+  void set_allocated_message(::proto::Message* message);
+  private:
+  const ::proto::Message& _internal_message() const;
+  ::proto::Message* _internal_mutable_message();
+  public:
+  void unsafe_arena_set_allocated_message(
+      ::proto::Message* message);
+  ::proto::Message* unsafe_arena_release_message();
+
+  // optional uint64 messageTimestamp = 3;
+  bool has_messagetimestamp() const;
+  private:
+  bool _internal_has_messagetimestamp() const;
+  public:
+  void clear_messagetimestamp();
+  uint64_t messagetimestamp() const;
+  void set_messagetimestamp(uint64_t value);
+  private:
+  uint64_t _internal_messagetimestamp() const;
+  void _internal_set_messagetimestamp(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.NotificationMessageInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
+    ::proto::MessageKey* key_;
+    ::proto::Message* message_;
+    uint64_t messagetimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PastParticipant final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipant) */ {
+ public:
+  inline PastParticipant() : PastParticipant(nullptr) {}
+  ~PastParticipant() override;
+  explicit PROTOBUF_CONSTEXPR PastParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PastParticipant(const PastParticipant& from);
+  PastParticipant(PastParticipant&& from) noexcept
+    : PastParticipant() {
+    *this = ::std::move(from);
+  }
+
+  inline PastParticipant& operator=(const PastParticipant& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PastParticipant& operator=(PastParticipant&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PastParticipant& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PastParticipant* internal_default_instance() {
+    return reinterpret_cast<const PastParticipant*>(
+               &_PastParticipant_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    147;
+
+  friend void swap(PastParticipant& a, PastParticipant& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PastParticipant* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PastParticipant* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PastParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PastParticipant>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PastParticipant& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PastParticipant& from) {
+    PastParticipant::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PastParticipant* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PastParticipant";
+  }
+  protected:
+  explicit PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PastParticipant_LeaveReason LeaveReason;
+  static constexpr LeaveReason LEFT =
+    PastParticipant_LeaveReason_LEFT;
+  static constexpr LeaveReason REMOVED =
+    PastParticipant_LeaveReason_REMOVED;
+  static inline bool LeaveReason_IsValid(int value) {
+    return PastParticipant_LeaveReason_IsValid(value);
+  }
+  static constexpr LeaveReason LeaveReason_MIN =
+    PastParticipant_LeaveReason_LeaveReason_MIN;
+  static constexpr LeaveReason LeaveReason_MAX =
+    PastParticipant_LeaveReason_LeaveReason_MAX;
+  static constexpr int LeaveReason_ARRAYSIZE =
+    PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  LeaveReason_descriptor() {
+    return PastParticipant_LeaveReason_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& LeaveReason_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, LeaveReason>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function LeaveReason_Name.");
+    return PastParticipant_LeaveReason_Name(enum_t_value);
+  }
+  static inline bool LeaveReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      LeaveReason* value) {
+    return PastParticipant_LeaveReason_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUserJidFieldNumber = 1,
+    kLeaveTsFieldNumber = 3,
+    kLeaveReasonFieldNumber = 2,
+  };
+  // required string userJid = 1;
+  bool has_userjid() const;
+  private:
+  bool _internal_has_userjid() const;
+  public:
+  void clear_userjid();
+  const std::string& userjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_userjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_userjid();
+  PROTOBUF_NODISCARD std::string* release_userjid();
+  void set_allocated_userjid(std::string* userjid);
+  private:
+  const std::string& _internal_userjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
+  std::string* _internal_mutable_userjid();
+  public:
+
+  // required uint64 leaveTs = 3;
+  bool has_leavets() const;
+  private:
+  bool _internal_has_leavets() const;
+  public:
+  void clear_leavets();
+  uint64_t leavets() const;
+  void set_leavets(uint64_t value);
+  private:
+  uint64_t _internal_leavets() const;
+  void _internal_set_leavets(uint64_t value);
+  public:
+
+  // required .proto.PastParticipant.LeaveReason leaveReason = 2;
+  bool has_leavereason() const;
+  private:
+  bool _internal_has_leavereason() const;
+  public:
+  void clear_leavereason();
+  ::proto::PastParticipant_LeaveReason leavereason() const;
+  void set_leavereason(::proto::PastParticipant_LeaveReason value);
+  private:
+  ::proto::PastParticipant_LeaveReason _internal_leavereason() const;
+  void _internal_set_leavereason(::proto::PastParticipant_LeaveReason value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PastParticipant)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_;
+    uint64_t leavets_;
+    int leavereason_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PastParticipants final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipants) */ {
+ public:
+  inline PastParticipants() : PastParticipants(nullptr) {}
+  ~PastParticipants() override;
+  explicit PROTOBUF_CONSTEXPR PastParticipants(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PastParticipants(const PastParticipants& from);
+  PastParticipants(PastParticipants&& from) noexcept
+    : PastParticipants() {
+    *this = ::std::move(from);
+  }
+
+  inline PastParticipants& operator=(const PastParticipants& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PastParticipants& operator=(PastParticipants&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PastParticipants& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PastParticipants* internal_default_instance() {
+    return reinterpret_cast<const PastParticipants*>(
+               &_PastParticipants_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    148;
+
+  friend void swap(PastParticipants& a, PastParticipants& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PastParticipants* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PastParticipants* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PastParticipants* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PastParticipants>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PastParticipants& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PastParticipants& from) {
+    PastParticipants::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PastParticipants* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PastParticipants";
+  }
+  protected:
+  explicit PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPastParticipantsFieldNumber = 2,
+    kGroupJidFieldNumber = 1,
+  };
+  // repeated .proto.PastParticipant pastParticipants = 2;
+  int pastparticipants_size() const;
+  private:
+  int _internal_pastparticipants_size() const;
+  public:
+  void clear_pastparticipants();
+  ::proto::PastParticipant* mutable_pastparticipants(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >*
+      mutable_pastparticipants();
+  private:
+  const ::proto::PastParticipant& _internal_pastparticipants(int index) const;
+  ::proto::PastParticipant* _internal_add_pastparticipants();
+  public:
+  const ::proto::PastParticipant& pastparticipants(int index) const;
+  ::proto::PastParticipant* add_pastparticipants();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >&
+      pastparticipants() const;
+
+  // required string groupJid = 1;
+  bool has_groupjid() const;
+  private:
+  bool _internal_has_groupjid() const;
+  public:
+  void clear_groupjid();
+  const std::string& groupjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupjid();
+  PROTOBUF_NODISCARD std::string* release_groupjid();
+  void set_allocated_groupjid(std::string* groupjid);
+  private:
+  const std::string& _internal_groupjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value);
+  std::string* _internal_mutable_groupjid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PastParticipants)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant > pastparticipants_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PaymentBackground_MediaData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground.MediaData) */ {
+ public:
+  inline PaymentBackground_MediaData() : PaymentBackground_MediaData(nullptr) {}
+  ~PaymentBackground_MediaData() override;
+  explicit PROTOBUF_CONSTEXPR PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PaymentBackground_MediaData(const PaymentBackground_MediaData& from);
+  PaymentBackground_MediaData(PaymentBackground_MediaData&& from) noexcept
+    : PaymentBackground_MediaData() {
+    *this = ::std::move(from);
+  }
+
+  inline PaymentBackground_MediaData& operator=(const PaymentBackground_MediaData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PaymentBackground_MediaData& operator=(PaymentBackground_MediaData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PaymentBackground_MediaData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PaymentBackground_MediaData* internal_default_instance() {
+    return reinterpret_cast<const PaymentBackground_MediaData*>(
+               &_PaymentBackground_MediaData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    149;
+
+  friend void swap(PaymentBackground_MediaData& a, PaymentBackground_MediaData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PaymentBackground_MediaData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PaymentBackground_MediaData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PaymentBackground_MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PaymentBackground_MediaData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PaymentBackground_MediaData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PaymentBackground_MediaData& from) {
+    PaymentBackground_MediaData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PaymentBackground_MediaData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PaymentBackground.MediaData";
+  }
+  protected:
+  explicit PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMediaKeyFieldNumber = 1,
+    kFileSha256FieldNumber = 3,
+    kFileEncSha256FieldNumber = 4,
+    kDirectPathFieldNumber = 5,
+    kMediaKeyTimestampFieldNumber = 2,
+  };
+  // optional bytes mediaKey = 1;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional bytes fileSha256 = 3;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes fileEncSha256 = 4;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional string directPath = 5;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional int64 mediaKeyTimestamp = 2;
+  bool has_mediakeytimestamp() const;
+  private:
+  bool _internal_has_mediakeytimestamp() const;
+  public:
+  void clear_mediakeytimestamp();
+  int64_t mediakeytimestamp() const;
+  void set_mediakeytimestamp(int64_t value);
+  private:
+  int64_t _internal_mediakeytimestamp() const;
+  void _internal_set_mediakeytimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PaymentBackground.MediaData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    int64_t mediakeytimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PaymentBackground final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground) */ {
+ public:
+  inline PaymentBackground() : PaymentBackground(nullptr) {}
+  ~PaymentBackground() override;
+  explicit PROTOBUF_CONSTEXPR PaymentBackground(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PaymentBackground(const PaymentBackground& from);
+  PaymentBackground(PaymentBackground&& from) noexcept
+    : PaymentBackground() {
+    *this = ::std::move(from);
+  }
+
+  inline PaymentBackground& operator=(const PaymentBackground& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PaymentBackground& operator=(PaymentBackground&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PaymentBackground& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PaymentBackground* internal_default_instance() {
+    return reinterpret_cast<const PaymentBackground*>(
+               &_PaymentBackground_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    150;
+
+  friend void swap(PaymentBackground& a, PaymentBackground& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PaymentBackground* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PaymentBackground* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PaymentBackground* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PaymentBackground>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PaymentBackground& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PaymentBackground& from) {
+    PaymentBackground::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PaymentBackground* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PaymentBackground";
+  }
+  protected:
+  explicit PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PaymentBackground_MediaData MediaData;
+
+  typedef PaymentBackground_Type Type;
+  static constexpr Type UNKNOWN =
+    PaymentBackground_Type_UNKNOWN;
+  static constexpr Type DEFAULT =
+    PaymentBackground_Type_DEFAULT;
+  static inline bool Type_IsValid(int value) {
+    return PaymentBackground_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    PaymentBackground_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    PaymentBackground_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    PaymentBackground_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return PaymentBackground_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return PaymentBackground_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return PaymentBackground_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kMimetypeFieldNumber = 5,
+    kMediaDataFieldNumber = 9,
+    kFileLengthFieldNumber = 2,
+    kWidthFieldNumber = 3,
+    kHeightFieldNumber = 4,
+    kPlaceholderArgbFieldNumber = 6,
+    kTextArgbFieldNumber = 7,
+    kSubtextArgbFieldNumber = 8,
+    kTypeFieldNumber = 10,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional string mimetype = 5;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional .proto.PaymentBackground.MediaData mediaData = 9;
+  bool has_mediadata() const;
+  private:
+  bool _internal_has_mediadata() const;
+  public:
+  void clear_mediadata();
+  const ::proto::PaymentBackground_MediaData& mediadata() const;
+  PROTOBUF_NODISCARD ::proto::PaymentBackground_MediaData* release_mediadata();
+  ::proto::PaymentBackground_MediaData* mutable_mediadata();
+  void set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata);
+  private:
+  const ::proto::PaymentBackground_MediaData& _internal_mediadata() const;
+  ::proto::PaymentBackground_MediaData* _internal_mutable_mediadata();
+  public:
+  void unsafe_arena_set_allocated_mediadata(
+      ::proto::PaymentBackground_MediaData* mediadata);
+  ::proto::PaymentBackground_MediaData* unsafe_arena_release_mediadata();
+
+  // optional uint64 fileLength = 2;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional uint32 width = 3;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional uint32 height = 4;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional fixed32 placeholderArgb = 6;
+  bool has_placeholderargb() const;
+  private:
+  bool _internal_has_placeholderargb() const;
+  public:
+  void clear_placeholderargb();
+  uint32_t placeholderargb() const;
+  void set_placeholderargb(uint32_t value);
+  private:
+  uint32_t _internal_placeholderargb() const;
+  void _internal_set_placeholderargb(uint32_t value);
+  public:
+
+  // optional fixed32 textArgb = 7;
+  bool has_textargb() const;
+  private:
+  bool _internal_has_textargb() const;
+  public:
+  void clear_textargb();
+  uint32_t textargb() const;
+  void set_textargb(uint32_t value);
+  private:
+  uint32_t _internal_textargb() const;
+  void _internal_set_textargb(uint32_t value);
+  public:
+
+  // optional fixed32 subtextArgb = 8;
+  bool has_subtextargb() const;
+  private:
+  bool _internal_has_subtextargb() const;
+  public:
+  void clear_subtextargb();
+  uint32_t subtextargb() const;
+  void set_subtextargb(uint32_t value);
+  private:
+  uint32_t _internal_subtextargb() const;
+  void _internal_set_subtextargb(uint32_t value);
+  public:
+
+  // optional .proto.PaymentBackground.Type type = 10;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::proto::PaymentBackground_Type type() const;
+  void set_type(::proto::PaymentBackground_Type value);
+  private:
+  ::proto::PaymentBackground_Type _internal_type() const;
+  void _internal_set_type(::proto::PaymentBackground_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PaymentBackground)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::proto::PaymentBackground_MediaData* mediadata_;
+    uint64_t filelength_;
+    uint32_t width_;
+    uint32_t height_;
+    uint32_t placeholderargb_;
+    uint32_t textargb_;
+    uint32_t subtextargb_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PaymentInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentInfo) */ {
+ public:
+  inline PaymentInfo() : PaymentInfo(nullptr) {}
+  ~PaymentInfo() override;
+  explicit PROTOBUF_CONSTEXPR PaymentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PaymentInfo(const PaymentInfo& from);
+  PaymentInfo(PaymentInfo&& from) noexcept
+    : PaymentInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline PaymentInfo& operator=(const PaymentInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PaymentInfo& operator=(PaymentInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PaymentInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PaymentInfo* internal_default_instance() {
+    return reinterpret_cast<const PaymentInfo*>(
+               &_PaymentInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    151;
+
+  friend void swap(PaymentInfo& a, PaymentInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PaymentInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PaymentInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PaymentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PaymentInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PaymentInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PaymentInfo& from) {
+    PaymentInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PaymentInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PaymentInfo";
+  }
+  protected:
+  explicit PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PaymentInfo_Currency Currency;
+  static constexpr Currency UNKNOWN_CURRENCY =
+    PaymentInfo_Currency_UNKNOWN_CURRENCY;
+  static constexpr Currency INR =
+    PaymentInfo_Currency_INR;
+  static inline bool Currency_IsValid(int value) {
+    return PaymentInfo_Currency_IsValid(value);
+  }
+  static constexpr Currency Currency_MIN =
+    PaymentInfo_Currency_Currency_MIN;
+  static constexpr Currency Currency_MAX =
+    PaymentInfo_Currency_Currency_MAX;
+  static constexpr int Currency_ARRAYSIZE =
+    PaymentInfo_Currency_Currency_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Currency_descriptor() {
+    return PaymentInfo_Currency_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Currency_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Currency>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Currency_Name.");
+    return PaymentInfo_Currency_Name(enum_t_value);
+  }
+  static inline bool Currency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Currency* value) {
+    return PaymentInfo_Currency_Parse(name, value);
+  }
+
+  typedef PaymentInfo_Status Status;
+  static constexpr Status UNKNOWN_STATUS =
+    PaymentInfo_Status_UNKNOWN_STATUS;
+  static constexpr Status PROCESSING =
+    PaymentInfo_Status_PROCESSING;
+  static constexpr Status SENT =
+    PaymentInfo_Status_SENT;
+  static constexpr Status NEED_TO_ACCEPT =
+    PaymentInfo_Status_NEED_TO_ACCEPT;
+  static constexpr Status COMPLETE =
+    PaymentInfo_Status_COMPLETE;
+  static constexpr Status COULD_NOT_COMPLETE =
+    PaymentInfo_Status_COULD_NOT_COMPLETE;
+  static constexpr Status REFUNDED =
+    PaymentInfo_Status_REFUNDED;
+  static constexpr Status EXPIRED =
+    PaymentInfo_Status_EXPIRED;
+  static constexpr Status REJECTED =
+    PaymentInfo_Status_REJECTED;
+  static constexpr Status CANCELLED =
+    PaymentInfo_Status_CANCELLED;
+  static constexpr Status WAITING_FOR_PAYER =
+    PaymentInfo_Status_WAITING_FOR_PAYER;
+  static constexpr Status WAITING =
+    PaymentInfo_Status_WAITING;
+  static inline bool Status_IsValid(int value) {
+    return PaymentInfo_Status_IsValid(value);
+  }
+  static constexpr Status Status_MIN =
+    PaymentInfo_Status_Status_MIN;
+  static constexpr Status Status_MAX =
+    PaymentInfo_Status_Status_MAX;
+  static constexpr int Status_ARRAYSIZE =
+    PaymentInfo_Status_Status_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Status_descriptor() {
+    return PaymentInfo_Status_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Status_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Status>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Status_Name.");
+    return PaymentInfo_Status_Name(enum_t_value);
+  }
+  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Status* value) {
+    return PaymentInfo_Status_Parse(name, value);
+  }
+
+  typedef PaymentInfo_TxnStatus TxnStatus;
+  static constexpr TxnStatus UNKNOWN =
+    PaymentInfo_TxnStatus_UNKNOWN;
+  static constexpr TxnStatus PENDING_SETUP =
+    PaymentInfo_TxnStatus_PENDING_SETUP;
+  static constexpr TxnStatus PENDING_RECEIVER_SETUP =
+    PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP;
+  static constexpr TxnStatus INIT =
+    PaymentInfo_TxnStatus_INIT;
+  static constexpr TxnStatus SUCCESS =
+    PaymentInfo_TxnStatus_SUCCESS;
+  static constexpr TxnStatus COMPLETED =
+    PaymentInfo_TxnStatus_COMPLETED;
+  static constexpr TxnStatus FAILED =
+    PaymentInfo_TxnStatus_FAILED;
+  static constexpr TxnStatus FAILED_RISK =
+    PaymentInfo_TxnStatus_FAILED_RISK;
+  static constexpr TxnStatus FAILED_PROCESSING =
+    PaymentInfo_TxnStatus_FAILED_PROCESSING;
+  static constexpr TxnStatus FAILED_RECEIVER_PROCESSING =
+    PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING;
+  static constexpr TxnStatus FAILED_DA =
+    PaymentInfo_TxnStatus_FAILED_DA;
+  static constexpr TxnStatus FAILED_DA_FINAL =
+    PaymentInfo_TxnStatus_FAILED_DA_FINAL;
+  static constexpr TxnStatus REFUNDED_TXN =
+    PaymentInfo_TxnStatus_REFUNDED_TXN;
+  static constexpr TxnStatus REFUND_FAILED =
+    PaymentInfo_TxnStatus_REFUND_FAILED;
+  static constexpr TxnStatus REFUND_FAILED_PROCESSING =
+    PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING;
+  static constexpr TxnStatus REFUND_FAILED_DA =
+    PaymentInfo_TxnStatus_REFUND_FAILED_DA;
+  static constexpr TxnStatus EXPIRED_TXN =
+    PaymentInfo_TxnStatus_EXPIRED_TXN;
+  static constexpr TxnStatus AUTH_CANCELED =
+    PaymentInfo_TxnStatus_AUTH_CANCELED;
+  static constexpr TxnStatus AUTH_CANCEL_FAILED_PROCESSING =
+    PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING;
+  static constexpr TxnStatus AUTH_CANCEL_FAILED =
+    PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED;
+  static constexpr TxnStatus COLLECT_INIT =
+    PaymentInfo_TxnStatus_COLLECT_INIT;
+  static constexpr TxnStatus COLLECT_SUCCESS =
+    PaymentInfo_TxnStatus_COLLECT_SUCCESS;
+  static constexpr TxnStatus COLLECT_FAILED =
+    PaymentInfo_TxnStatus_COLLECT_FAILED;
+  static constexpr TxnStatus COLLECT_FAILED_RISK =
+    PaymentInfo_TxnStatus_COLLECT_FAILED_RISK;
+  static constexpr TxnStatus COLLECT_REJECTED =
+    PaymentInfo_TxnStatus_COLLECT_REJECTED;
+  static constexpr TxnStatus COLLECT_EXPIRED =
+    PaymentInfo_TxnStatus_COLLECT_EXPIRED;
+  static constexpr TxnStatus COLLECT_CANCELED =
+    PaymentInfo_TxnStatus_COLLECT_CANCELED;
+  static constexpr TxnStatus COLLECT_CANCELLING =
+    PaymentInfo_TxnStatus_COLLECT_CANCELLING;
+  static constexpr TxnStatus IN_REVIEW =
+    PaymentInfo_TxnStatus_IN_REVIEW;
+  static constexpr TxnStatus REVERSAL_SUCCESS =
+    PaymentInfo_TxnStatus_REVERSAL_SUCCESS;
+  static constexpr TxnStatus REVERSAL_PENDING =
+    PaymentInfo_TxnStatus_REVERSAL_PENDING;
+  static constexpr TxnStatus REFUND_PENDING =
+    PaymentInfo_TxnStatus_REFUND_PENDING;
+  static inline bool TxnStatus_IsValid(int value) {
+    return PaymentInfo_TxnStatus_IsValid(value);
+  }
+  static constexpr TxnStatus TxnStatus_MIN =
+    PaymentInfo_TxnStatus_TxnStatus_MIN;
+  static constexpr TxnStatus TxnStatus_MAX =
+    PaymentInfo_TxnStatus_TxnStatus_MAX;
+  static constexpr int TxnStatus_ARRAYSIZE =
+    PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  TxnStatus_descriptor() {
+    return PaymentInfo_TxnStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& TxnStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, TxnStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function TxnStatus_Name.");
+    return PaymentInfo_TxnStatus_Name(enum_t_value);
+  }
+  static inline bool TxnStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      TxnStatus* value) {
+    return PaymentInfo_TxnStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReceiverJidFieldNumber = 3,
+    kCurrencyFieldNumber = 9,
+    kRequestMessageKeyFieldNumber = 6,
+    kPrimaryAmountFieldNumber = 12,
+    kExchangeAmountFieldNumber = 13,
+    kAmount1000FieldNumber = 2,
+    kCurrencyDeprecatedFieldNumber = 1,
+    kStatusFieldNumber = 4,
+    kTransactionTimestampFieldNumber = 5,
+    kExpiryTimestampFieldNumber = 7,
+    kFutureproofedFieldNumber = 8,
+    kUseNoviFiatFormatFieldNumber = 11,
+    kTxnStatusFieldNumber = 10,
+  };
+  // optional string receiverJid = 3;
+  bool has_receiverjid() const;
+  private:
+  bool _internal_has_receiverjid() const;
+  public:
+  void clear_receiverjid();
+  const std::string& receiverjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_receiverjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_receiverjid();
+  PROTOBUF_NODISCARD std::string* release_receiverjid();
+  void set_allocated_receiverjid(std::string* receiverjid);
+  private:
+  const std::string& _internal_receiverjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_receiverjid(const std::string& value);
+  std::string* _internal_mutable_receiverjid();
+  public:
+
+  // optional string currency = 9;
+  bool has_currency() const;
+  private:
+  bool _internal_has_currency() const;
+  public:
+  void clear_currency();
+  const std::string& currency() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_currency(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_currency();
+  PROTOBUF_NODISCARD std::string* release_currency();
+  void set_allocated_currency(std::string* currency);
+  private:
+  const std::string& _internal_currency() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currency(const std::string& value);
+  std::string* _internal_mutable_currency();
+  public:
+
+  // optional .proto.MessageKey requestMessageKey = 6;
+  bool has_requestmessagekey() const;
+  private:
+  bool _internal_has_requestmessagekey() const;
+  public:
+  void clear_requestmessagekey();
+  const ::proto::MessageKey& requestmessagekey() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey();
+  ::proto::MessageKey* mutable_requestmessagekey();
+  void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey);
+  private:
+  const ::proto::MessageKey& _internal_requestmessagekey() const;
+  ::proto::MessageKey* _internal_mutable_requestmessagekey();
+  public:
+  void unsafe_arena_set_allocated_requestmessagekey(
+      ::proto::MessageKey* requestmessagekey);
+  ::proto::MessageKey* unsafe_arena_release_requestmessagekey();
+
+  // optional .proto.Money primaryAmount = 12;
+  bool has_primaryamount() const;
+  private:
+  bool _internal_has_primaryamount() const;
+  public:
+  void clear_primaryamount();
+  const ::proto::Money& primaryamount() const;
+  PROTOBUF_NODISCARD ::proto::Money* release_primaryamount();
+  ::proto::Money* mutable_primaryamount();
+  void set_allocated_primaryamount(::proto::Money* primaryamount);
+  private:
+  const ::proto::Money& _internal_primaryamount() const;
+  ::proto::Money* _internal_mutable_primaryamount();
+  public:
+  void unsafe_arena_set_allocated_primaryamount(
+      ::proto::Money* primaryamount);
+  ::proto::Money* unsafe_arena_release_primaryamount();
+
+  // optional .proto.Money exchangeAmount = 13;
+  bool has_exchangeamount() const;
+  private:
+  bool _internal_has_exchangeamount() const;
+  public:
+  void clear_exchangeamount();
+  const ::proto::Money& exchangeamount() const;
+  PROTOBUF_NODISCARD ::proto::Money* release_exchangeamount();
+  ::proto::Money* mutable_exchangeamount();
+  void set_allocated_exchangeamount(::proto::Money* exchangeamount);
+  private:
+  const ::proto::Money& _internal_exchangeamount() const;
+  ::proto::Money* _internal_mutable_exchangeamount();
+  public:
+  void unsafe_arena_set_allocated_exchangeamount(
+      ::proto::Money* exchangeamount);
+  ::proto::Money* unsafe_arena_release_exchangeamount();
+
+  // optional uint64 amount1000 = 2;
+  bool has_amount1000() const;
+  private:
+  bool _internal_has_amount1000() const;
+  public:
+  void clear_amount1000();
+  uint64_t amount1000() const;
+  void set_amount1000(uint64_t value);
+  private:
+  uint64_t _internal_amount1000() const;
+  void _internal_set_amount1000(uint64_t value);
+  public:
+
+  // optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
+  bool has_currencydeprecated() const;
+  private:
+  bool _internal_has_currencydeprecated() const;
+  public:
+  void clear_currencydeprecated();
+  ::proto::PaymentInfo_Currency currencydeprecated() const;
+  void set_currencydeprecated(::proto::PaymentInfo_Currency value);
+  private:
+  ::proto::PaymentInfo_Currency _internal_currencydeprecated() const;
+  void _internal_set_currencydeprecated(::proto::PaymentInfo_Currency value);
+  public:
+
+  // optional .proto.PaymentInfo.Status status = 4;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::proto::PaymentInfo_Status status() const;
+  void set_status(::proto::PaymentInfo_Status value);
+  private:
+  ::proto::PaymentInfo_Status _internal_status() const;
+  void _internal_set_status(::proto::PaymentInfo_Status value);
+  public:
+
+  // optional uint64 transactionTimestamp = 5;
+  bool has_transactiontimestamp() const;
+  private:
+  bool _internal_has_transactiontimestamp() const;
+  public:
+  void clear_transactiontimestamp();
+  uint64_t transactiontimestamp() const;
+  void set_transactiontimestamp(uint64_t value);
+  private:
+  uint64_t _internal_transactiontimestamp() const;
+  void _internal_set_transactiontimestamp(uint64_t value);
+  public:
+
+  // optional uint64 expiryTimestamp = 7;
+  bool has_expirytimestamp() const;
+  private:
+  bool _internal_has_expirytimestamp() const;
+  public:
+  void clear_expirytimestamp();
+  uint64_t expirytimestamp() const;
+  void set_expirytimestamp(uint64_t value);
+  private:
+  uint64_t _internal_expirytimestamp() const;
+  void _internal_set_expirytimestamp(uint64_t value);
+  public:
+
+  // optional bool futureproofed = 8;
+  bool has_futureproofed() const;
+  private:
+  bool _internal_has_futureproofed() const;
+  public:
+  void clear_futureproofed();
+  bool futureproofed() const;
+  void set_futureproofed(bool value);
+  private:
+  bool _internal_futureproofed() const;
+  void _internal_set_futureproofed(bool value);
+  public:
+
+  // optional bool useNoviFiatFormat = 11;
+  bool has_usenovifiatformat() const;
+  private:
+  bool _internal_has_usenovifiatformat() const;
+  public:
+  void clear_usenovifiatformat();
+  bool usenovifiatformat() const;
+  void set_usenovifiatformat(bool value);
+  private:
+  bool _internal_usenovifiatformat() const;
+  void _internal_set_usenovifiatformat(bool value);
+  public:
+
+  // optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
+  bool has_txnstatus() const;
+  private:
+  bool _internal_has_txnstatus() const;
+  public:
+  void clear_txnstatus();
+  ::proto::PaymentInfo_TxnStatus txnstatus() const;
+  void set_txnstatus(::proto::PaymentInfo_TxnStatus value);
+  private:
+  ::proto::PaymentInfo_TxnStatus _internal_txnstatus() const;
+  void _internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PaymentInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr receiverjid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currency_;
+    ::proto::MessageKey* requestmessagekey_;
+    ::proto::Money* primaryamount_;
+    ::proto::Money* exchangeamount_;
+    uint64_t amount1000_;
+    int currencydeprecated_;
+    int status_;
+    uint64_t transactiontimestamp_;
+    uint64_t expirytimestamp_;
+    bool futureproofed_;
+    bool usenovifiatformat_;
+    int txnstatus_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PendingKeyExchange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingKeyExchange) */ {
+ public:
+  inline PendingKeyExchange() : PendingKeyExchange(nullptr) {}
+  ~PendingKeyExchange() override;
+  explicit PROTOBUF_CONSTEXPR PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PendingKeyExchange(const PendingKeyExchange& from);
+  PendingKeyExchange(PendingKeyExchange&& from) noexcept
+    : PendingKeyExchange() {
+    *this = ::std::move(from);
+  }
+
+  inline PendingKeyExchange& operator=(const PendingKeyExchange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PendingKeyExchange& operator=(PendingKeyExchange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PendingKeyExchange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PendingKeyExchange* internal_default_instance() {
+    return reinterpret_cast<const PendingKeyExchange*>(
+               &_PendingKeyExchange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    152;
+
+  friend void swap(PendingKeyExchange& a, PendingKeyExchange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PendingKeyExchange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PendingKeyExchange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PendingKeyExchange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PendingKeyExchange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PendingKeyExchange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PendingKeyExchange& from) {
+    PendingKeyExchange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PendingKeyExchange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PendingKeyExchange";
+  }
+  protected:
+  explicit PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLocalBaseKeyFieldNumber = 2,
+    kLocalBaseKeyPrivateFieldNumber = 3,
+    kLocalRatchetKeyFieldNumber = 4,
+    kLocalRatchetKeyPrivateFieldNumber = 5,
+    kLocalIdentityKeyFieldNumber = 7,
+    kLocalIdentityKeyPrivateFieldNumber = 8,
+    kSequenceFieldNumber = 1,
+  };
+  // optional bytes localBaseKey = 2;
+  bool has_localbasekey() const;
+  private:
+  bool _internal_has_localbasekey() const;
+  public:
+  void clear_localbasekey();
+  const std::string& localbasekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localbasekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localbasekey();
+  PROTOBUF_NODISCARD std::string* release_localbasekey();
+  void set_allocated_localbasekey(std::string* localbasekey);
+  private:
+  const std::string& _internal_localbasekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekey(const std::string& value);
+  std::string* _internal_mutable_localbasekey();
+  public:
+
+  // optional bytes localBaseKeyPrivate = 3;
+  bool has_localbasekeyprivate() const;
+  private:
+  bool _internal_has_localbasekeyprivate() const;
+  public:
+  void clear_localbasekeyprivate();
+  const std::string& localbasekeyprivate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localbasekeyprivate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localbasekeyprivate();
+  PROTOBUF_NODISCARD std::string* release_localbasekeyprivate();
+  void set_allocated_localbasekeyprivate(std::string* localbasekeyprivate);
+  private:
+  const std::string& _internal_localbasekeyprivate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekeyprivate(const std::string& value);
+  std::string* _internal_mutable_localbasekeyprivate();
+  public:
+
+  // optional bytes localRatchetKey = 4;
+  bool has_localratchetkey() const;
+  private:
+  bool _internal_has_localratchetkey() const;
+  public:
+  void clear_localratchetkey();
+  const std::string& localratchetkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localratchetkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localratchetkey();
+  PROTOBUF_NODISCARD std::string* release_localratchetkey();
+  void set_allocated_localratchetkey(std::string* localratchetkey);
+  private:
+  const std::string& _internal_localratchetkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkey(const std::string& value);
+  std::string* _internal_mutable_localratchetkey();
+  public:
+
+  // optional bytes localRatchetKeyPrivate = 5;
+  bool has_localratchetkeyprivate() const;
+  private:
+  bool _internal_has_localratchetkeyprivate() const;
+  public:
+  void clear_localratchetkeyprivate();
+  const std::string& localratchetkeyprivate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localratchetkeyprivate();
+  PROTOBUF_NODISCARD std::string* release_localratchetkeyprivate();
+  void set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate);
+  private:
+  const std::string& _internal_localratchetkeyprivate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkeyprivate(const std::string& value);
+  std::string* _internal_mutable_localratchetkeyprivate();
+  public:
+
+  // optional bytes localIdentityKey = 7;
+  bool has_localidentitykey() const;
+  private:
+  bool _internal_has_localidentitykey() const;
+  public:
+  void clear_localidentitykey();
+  const std::string& localidentitykey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localidentitykey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localidentitykey();
+  PROTOBUF_NODISCARD std::string* release_localidentitykey();
+  void set_allocated_localidentitykey(std::string* localidentitykey);
+  private:
+  const std::string& _internal_localidentitykey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykey(const std::string& value);
+  std::string* _internal_mutable_localidentitykey();
+  public:
+
+  // optional bytes localIdentityKeyPrivate = 8;
+  bool has_localidentitykeyprivate() const;
+  private:
+  bool _internal_has_localidentitykeyprivate() const;
+  public:
+  void clear_localidentitykeyprivate();
+  const std::string& localidentitykeyprivate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localidentitykeyprivate();
+  PROTOBUF_NODISCARD std::string* release_localidentitykeyprivate();
+  void set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate);
+  private:
+  const std::string& _internal_localidentitykeyprivate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykeyprivate(const std::string& value);
+  std::string* _internal_mutable_localidentitykeyprivate();
+  public:
+
+  // optional uint32 sequence = 1;
+  bool has_sequence() const;
+  private:
+  bool _internal_has_sequence() const;
+  public:
+  void clear_sequence();
+  uint32_t sequence() const;
+  void set_sequence(uint32_t value);
+  private:
+  uint32_t _internal_sequence() const;
+  void _internal_set_sequence(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PendingKeyExchange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekeyprivate_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkeyprivate_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykeyprivate_;
+    uint32_t sequence_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PendingPreKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingPreKey) */ {
+ public:
+  inline PendingPreKey() : PendingPreKey(nullptr) {}
+  ~PendingPreKey() override;
+  explicit PROTOBUF_CONSTEXPR PendingPreKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PendingPreKey(const PendingPreKey& from);
+  PendingPreKey(PendingPreKey&& from) noexcept
+    : PendingPreKey() {
+    *this = ::std::move(from);
+  }
+
+  inline PendingPreKey& operator=(const PendingPreKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PendingPreKey& operator=(PendingPreKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PendingPreKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PendingPreKey* internal_default_instance() {
+    return reinterpret_cast<const PendingPreKey*>(
+               &_PendingPreKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    153;
+
+  friend void swap(PendingPreKey& a, PendingPreKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PendingPreKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PendingPreKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PendingPreKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PendingPreKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PendingPreKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PendingPreKey& from) {
+    PendingPreKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PendingPreKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PendingPreKey";
+  }
+  protected:
+  explicit PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBaseKeyFieldNumber = 2,
+    kPreKeyIdFieldNumber = 1,
+    kSignedPreKeyIdFieldNumber = 3,
+  };
+  // optional bytes baseKey = 2;
+  bool has_basekey() const;
+  private:
+  bool _internal_has_basekey() const;
+  public:
+  void clear_basekey();
+  const std::string& basekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_basekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_basekey();
+  PROTOBUF_NODISCARD std::string* release_basekey();
+  void set_allocated_basekey(std::string* basekey);
+  private:
+  const std::string& _internal_basekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_basekey(const std::string& value);
+  std::string* _internal_mutable_basekey();
+  public:
+
+  // optional uint32 preKeyId = 1;
+  bool has_prekeyid() const;
+  private:
+  bool _internal_has_prekeyid() const;
+  public:
+  void clear_prekeyid();
+  uint32_t prekeyid() const;
+  void set_prekeyid(uint32_t value);
+  private:
+  uint32_t _internal_prekeyid() const;
+  void _internal_set_prekeyid(uint32_t value);
+  public:
+
+  // optional int32 signedPreKeyId = 3;
+  bool has_signedprekeyid() const;
+  private:
+  bool _internal_has_signedprekeyid() const;
+  public:
+  void clear_signedprekeyid();
+  int32_t signedprekeyid() const;
+  void set_signedprekeyid(int32_t value);
+  private:
+  int32_t _internal_signedprekeyid() const;
+  void _internal_set_signedprekeyid(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PendingPreKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr basekey_;
+    uint32_t prekeyid_;
+    int32_t signedprekeyid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PhotoChange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PhotoChange) */ {
+ public:
+  inline PhotoChange() : PhotoChange(nullptr) {}
+  ~PhotoChange() override;
+  explicit PROTOBUF_CONSTEXPR PhotoChange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PhotoChange(const PhotoChange& from);
+  PhotoChange(PhotoChange&& from) noexcept
+    : PhotoChange() {
+    *this = ::std::move(from);
+  }
+
+  inline PhotoChange& operator=(const PhotoChange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PhotoChange& operator=(PhotoChange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PhotoChange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PhotoChange* internal_default_instance() {
+    return reinterpret_cast<const PhotoChange*>(
+               &_PhotoChange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    154;
+
+  friend void swap(PhotoChange& a, PhotoChange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PhotoChange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PhotoChange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PhotoChange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PhotoChange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PhotoChange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PhotoChange& from) {
+    PhotoChange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PhotoChange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PhotoChange";
+  }
+  protected:
+  explicit PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOldPhotoFieldNumber = 1,
+    kNewPhotoFieldNumber = 2,
+    kNewPhotoIdFieldNumber = 3,
+  };
+  // optional bytes oldPhoto = 1;
+  bool has_oldphoto() const;
+  private:
+  bool _internal_has_oldphoto() const;
+  public:
+  void clear_oldphoto();
+  const std::string& oldphoto() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oldphoto(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oldphoto();
+  PROTOBUF_NODISCARD std::string* release_oldphoto();
+  void set_allocated_oldphoto(std::string* oldphoto);
+  private:
+  const std::string& _internal_oldphoto() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldphoto(const std::string& value);
+  std::string* _internal_mutable_oldphoto();
+  public:
+
+  // optional bytes newPhoto = 2;
+  bool has_newphoto() const;
+  private:
+  bool _internal_has_newphoto() const;
+  public:
+  void clear_newphoto();
+  const std::string& newphoto() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_newphoto(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_newphoto();
+  PROTOBUF_NODISCARD std::string* release_newphoto();
+  void set_allocated_newphoto(std::string* newphoto);
+  private:
+  const std::string& _internal_newphoto() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_newphoto(const std::string& value);
+  std::string* _internal_mutable_newphoto();
+  public:
+
+  // optional uint32 newPhotoId = 3;
+  bool has_newphotoid() const;
+  private:
+  bool _internal_has_newphotoid() const;
+  public:
+  void clear_newphotoid();
+  uint32_t newphotoid() const;
+  void set_newphotoid(uint32_t value);
+  private:
+  uint32_t _internal_newphotoid() const;
+  void _internal_set_newphotoid(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PhotoChange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldphoto_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newphoto_;
+    uint32_t newphotoid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Point final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Point) */ {
+ public:
+  inline Point() : Point(nullptr) {}
+  ~Point() override;
+  explicit PROTOBUF_CONSTEXPR Point(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Point(const Point& from);
+  Point(Point&& from) noexcept
+    : Point() {
+    *this = ::std::move(from);
+  }
+
+  inline Point& operator=(const Point& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Point& operator=(Point&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Point& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Point* internal_default_instance() {
+    return reinterpret_cast<const Point*>(
+               &_Point_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    155;
+
+  friend void swap(Point& a, Point& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Point* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Point* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Point* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Point>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Point& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Point& from) {
+    Point::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Point* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Point";
+  }
+  protected:
+  explicit Point(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kXDeprecatedFieldNumber = 1,
+    kYDeprecatedFieldNumber = 2,
+    kXFieldNumber = 3,
+    kYFieldNumber = 4,
+  };
+  // optional int32 xDeprecated = 1;
+  bool has_xdeprecated() const;
+  private:
+  bool _internal_has_xdeprecated() const;
+  public:
+  void clear_xdeprecated();
+  int32_t xdeprecated() const;
+  void set_xdeprecated(int32_t value);
+  private:
+  int32_t _internal_xdeprecated() const;
+  void _internal_set_xdeprecated(int32_t value);
+  public:
+
+  // optional int32 yDeprecated = 2;
+  bool has_ydeprecated() const;
+  private:
+  bool _internal_has_ydeprecated() const;
+  public:
+  void clear_ydeprecated();
+  int32_t ydeprecated() const;
+  void set_ydeprecated(int32_t value);
+  private:
+  int32_t _internal_ydeprecated() const;
+  void _internal_set_ydeprecated(int32_t value);
+  public:
+
+  // optional double x = 3;
+  bool has_x() const;
+  private:
+  bool _internal_has_x() const;
+  public:
+  void clear_x();
+  double x() const;
+  void set_x(double value);
+  private:
+  double _internal_x() const;
+  void _internal_set_x(double value);
+  public:
+
+  // optional double y = 4;
+  bool has_y() const;
+  private:
+  bool _internal_has_y() const;
+  public:
+  void clear_y();
+  double y() const;
+  void set_y(double value);
+  private:
+  double _internal_y() const;
+  void _internal_set_y(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Point)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t xdeprecated_;
+    int32_t ydeprecated_;
+    double x_;
+    double y_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PollAdditionalMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollAdditionalMetadata) */ {
+ public:
+  inline PollAdditionalMetadata() : PollAdditionalMetadata(nullptr) {}
+  ~PollAdditionalMetadata() override;
+  explicit PROTOBUF_CONSTEXPR PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PollAdditionalMetadata(const PollAdditionalMetadata& from);
+  PollAdditionalMetadata(PollAdditionalMetadata&& from) noexcept
+    : PollAdditionalMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline PollAdditionalMetadata& operator=(const PollAdditionalMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PollAdditionalMetadata& operator=(PollAdditionalMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PollAdditionalMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PollAdditionalMetadata* internal_default_instance() {
+    return reinterpret_cast<const PollAdditionalMetadata*>(
+               &_PollAdditionalMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    156;
+
+  friend void swap(PollAdditionalMetadata& a, PollAdditionalMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PollAdditionalMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PollAdditionalMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PollAdditionalMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PollAdditionalMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PollAdditionalMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PollAdditionalMetadata& from) {
+    PollAdditionalMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PollAdditionalMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PollAdditionalMetadata";
+  }
+  protected:
+  explicit PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPollInvalidatedFieldNumber = 1,
+  };
+  // optional bool pollInvalidated = 1;
+  bool has_pollinvalidated() const;
+  private:
+  bool _internal_has_pollinvalidated() const;
+  public:
+  void clear_pollinvalidated();
+  bool pollinvalidated() const;
+  void set_pollinvalidated(bool value);
+  private:
+  bool _internal_pollinvalidated() const;
+  void _internal_set_pollinvalidated(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PollAdditionalMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool pollinvalidated_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PollEncValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollEncValue) */ {
+ public:
+  inline PollEncValue() : PollEncValue(nullptr) {}
+  ~PollEncValue() override;
+  explicit PROTOBUF_CONSTEXPR PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PollEncValue(const PollEncValue& from);
+  PollEncValue(PollEncValue&& from) noexcept
+    : PollEncValue() {
+    *this = ::std::move(from);
+  }
+
+  inline PollEncValue& operator=(const PollEncValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PollEncValue& operator=(PollEncValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PollEncValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PollEncValue* internal_default_instance() {
+    return reinterpret_cast<const PollEncValue*>(
+               &_PollEncValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    157;
+
+  friend void swap(PollEncValue& a, PollEncValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PollEncValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PollEncValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PollEncValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PollEncValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PollEncValue& from) {
+    PollEncValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PollEncValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PollEncValue";
+  }
+  protected:
+  explicit PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncPayloadFieldNumber = 1,
+    kEncIvFieldNumber = 2,
+  };
+  // optional bytes encPayload = 1;
+  bool has_encpayload() const;
+  private:
+  bool _internal_has_encpayload() const;
+  public:
+  void clear_encpayload();
+  const std::string& encpayload() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encpayload(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encpayload();
+  PROTOBUF_NODISCARD std::string* release_encpayload();
+  void set_allocated_encpayload(std::string* encpayload);
+  private:
+  const std::string& _internal_encpayload() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value);
+  std::string* _internal_mutable_encpayload();
+  public:
+
+  // optional bytes encIv = 2;
+  bool has_enciv() const;
+  private:
+  bool _internal_has_enciv() const;
+  public:
+  void clear_enciv();
+  const std::string& enciv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_enciv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_enciv();
+  PROTOBUF_NODISCARD std::string* release_enciv();
+  void set_allocated_enciv(std::string* enciv);
+  private:
+  const std::string& _internal_enciv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value);
+  std::string* _internal_mutable_enciv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PollEncValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PollUpdate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollUpdate) */ {
+ public:
+  inline PollUpdate() : PollUpdate(nullptr) {}
+  ~PollUpdate() override;
+  explicit PROTOBUF_CONSTEXPR PollUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PollUpdate(const PollUpdate& from);
+  PollUpdate(PollUpdate&& from) noexcept
+    : PollUpdate() {
+    *this = ::std::move(from);
+  }
+
+  inline PollUpdate& operator=(const PollUpdate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PollUpdate& operator=(PollUpdate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PollUpdate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PollUpdate* internal_default_instance() {
+    return reinterpret_cast<const PollUpdate*>(
+               &_PollUpdate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    158;
+
+  friend void swap(PollUpdate& a, PollUpdate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PollUpdate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PollUpdate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PollUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PollUpdate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PollUpdate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PollUpdate& from) {
+    PollUpdate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PollUpdate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PollUpdate";
+  }
+  protected:
+  explicit PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPollUpdateMessageKeyFieldNumber = 1,
+    kVoteFieldNumber = 2,
+    kSenderTimestampMsFieldNumber = 3,
+  };
+  // optional .proto.MessageKey pollUpdateMessageKey = 1;
+  bool has_pollupdatemessagekey() const;
+  private:
+  bool _internal_has_pollupdatemessagekey() const;
+  public:
+  void clear_pollupdatemessagekey();
+  const ::proto::MessageKey& pollupdatemessagekey() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_pollupdatemessagekey();
+  ::proto::MessageKey* mutable_pollupdatemessagekey();
+  void set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey);
+  private:
+  const ::proto::MessageKey& _internal_pollupdatemessagekey() const;
+  ::proto::MessageKey* _internal_mutable_pollupdatemessagekey();
+  public:
+  void unsafe_arena_set_allocated_pollupdatemessagekey(
+      ::proto::MessageKey* pollupdatemessagekey);
+  ::proto::MessageKey* unsafe_arena_release_pollupdatemessagekey();
+
+  // optional .proto.Message.PollVoteMessage vote = 2;
+  bool has_vote() const;
+  private:
+  bool _internal_has_vote() const;
+  public:
+  void clear_vote();
+  const ::proto::Message_PollVoteMessage& vote() const;
+  PROTOBUF_NODISCARD ::proto::Message_PollVoteMessage* release_vote();
+  ::proto::Message_PollVoteMessage* mutable_vote();
+  void set_allocated_vote(::proto::Message_PollVoteMessage* vote);
+  private:
+  const ::proto::Message_PollVoteMessage& _internal_vote() const;
+  ::proto::Message_PollVoteMessage* _internal_mutable_vote();
+  public:
+  void unsafe_arena_set_allocated_vote(
+      ::proto::Message_PollVoteMessage* vote);
+  ::proto::Message_PollVoteMessage* unsafe_arena_release_vote();
+
+  // optional int64 senderTimestampMs = 3;
+  bool has_sendertimestampms() const;
+  private:
+  bool _internal_has_sendertimestampms() const;
+  public:
+  void clear_sendertimestampms();
+  int64_t sendertimestampms() const;
+  void set_sendertimestampms(int64_t value);
+  private:
+  int64_t _internal_sendertimestampms() const;
+  void _internal_set_sendertimestampms(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PollUpdate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* pollupdatemessagekey_;
+    ::proto::Message_PollVoteMessage* vote_;
+    int64_t sendertimestampms_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PreKeyRecordStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PreKeyRecordStructure) */ {
+ public:
+  inline PreKeyRecordStructure() : PreKeyRecordStructure(nullptr) {}
+  ~PreKeyRecordStructure() override;
+  explicit PROTOBUF_CONSTEXPR PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PreKeyRecordStructure(const PreKeyRecordStructure& from);
+  PreKeyRecordStructure(PreKeyRecordStructure&& from) noexcept
+    : PreKeyRecordStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline PreKeyRecordStructure& operator=(const PreKeyRecordStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PreKeyRecordStructure& operator=(PreKeyRecordStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PreKeyRecordStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PreKeyRecordStructure* internal_default_instance() {
+    return reinterpret_cast<const PreKeyRecordStructure*>(
+               &_PreKeyRecordStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    159;
+
+  friend void swap(PreKeyRecordStructure& a, PreKeyRecordStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PreKeyRecordStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PreKeyRecordStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PreKeyRecordStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PreKeyRecordStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PreKeyRecordStructure& from) {
+    PreKeyRecordStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PreKeyRecordStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.PreKeyRecordStructure";
+  }
+  protected:
+  explicit PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 2,
+    kPrivateKeyFieldNumber = 3,
+    kIdFieldNumber = 1,
+  };
+  // optional bytes publicKey = 2;
+  bool has_publickey() const;
+  private:
+  bool _internal_has_publickey() const;
+  public:
+  void clear_publickey();
+  const std::string& publickey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_publickey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_publickey();
+  PROTOBUF_NODISCARD std::string* release_publickey();
+  void set_allocated_publickey(std::string* publickey);
+  private:
+  const std::string& _internal_publickey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value);
+  std::string* _internal_mutable_publickey();
+  public:
+
+  // optional bytes privateKey = 3;
+  bool has_privatekey() const;
+  private:
+  bool _internal_has_privatekey() const;
+  public:
+  void clear_privatekey();
+  const std::string& privatekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_privatekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_privatekey();
+  PROTOBUF_NODISCARD std::string* release_privatekey();
+  void set_allocated_privatekey(std::string* privatekey);
+  private:
+  const std::string& _internal_privatekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value);
+  std::string* _internal_mutable_privatekey();
+  public:
+
+  // optional uint32 id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  uint32_t id() const;
+  void set_id(uint32_t value);
+  private:
+  uint32_t _internal_id() const;
+  void _internal_set_id(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.PreKeyRecordStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
+    uint32_t id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Pushname final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Pushname) */ {
+ public:
+  inline Pushname() : Pushname(nullptr) {}
+  ~Pushname() override;
+  explicit PROTOBUF_CONSTEXPR Pushname(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Pushname(const Pushname& from);
+  Pushname(Pushname&& from) noexcept
+    : Pushname() {
+    *this = ::std::move(from);
+  }
+
+  inline Pushname& operator=(const Pushname& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Pushname& operator=(Pushname&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Pushname& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Pushname* internal_default_instance() {
+    return reinterpret_cast<const Pushname*>(
+               &_Pushname_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    160;
+
+  friend void swap(Pushname& a, Pushname& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Pushname* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Pushname* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Pushname* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Pushname>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Pushname& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Pushname& from) {
+    Pushname::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Pushname* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Pushname";
+  }
+  protected:
+  explicit Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kPushnameFieldNumber = 2,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional string pushname = 2;
+  bool has_pushname() const;
+  private:
+  bool _internal_has_pushname() const;
+  public:
+  void clear_pushname();
+  const std::string& pushname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pushname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pushname();
+  PROTOBUF_NODISCARD std::string* release_pushname();
+  void set_allocated_pushname(std::string* pushname);
+  private:
+  const std::string& _internal_pushname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
+  std::string* _internal_mutable_pushname();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Pushname)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Reaction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Reaction) */ {
+ public:
+  inline Reaction() : Reaction(nullptr) {}
+  ~Reaction() override;
+  explicit PROTOBUF_CONSTEXPR Reaction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Reaction(const Reaction& from);
+  Reaction(Reaction&& from) noexcept
+    : Reaction() {
+    *this = ::std::move(from);
+  }
+
+  inline Reaction& operator=(const Reaction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Reaction& operator=(Reaction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Reaction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Reaction* internal_default_instance() {
+    return reinterpret_cast<const Reaction*>(
+               &_Reaction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    161;
+
+  friend void swap(Reaction& a, Reaction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Reaction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Reaction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Reaction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Reaction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Reaction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Reaction& from) {
+    Reaction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Reaction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.Reaction";
+  }
+  protected:
+  explicit Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTextFieldNumber = 2,
+    kGroupingKeyFieldNumber = 3,
+    kKeyFieldNumber = 1,
+    kSenderTimestampMsFieldNumber = 4,
+    kUnreadFieldNumber = 5,
+  };
+  // optional string text = 2;
+  bool has_text() const;
+  private:
+  bool _internal_has_text() const;
+  public:
+  void clear_text();
+  const std::string& text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_text();
+  PROTOBUF_NODISCARD std::string* release_text();
+  void set_allocated_text(std::string* text);
+  private:
+  const std::string& _internal_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+  std::string* _internal_mutable_text();
+  public:
+
+  // optional string groupingKey = 3;
+  bool has_groupingkey() const;
+  private:
+  bool _internal_has_groupingkey() const;
+  public:
+  void clear_groupingkey();
+  const std::string& groupingkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_groupingkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_groupingkey();
+  PROTOBUF_NODISCARD std::string* release_groupingkey();
+  void set_allocated_groupingkey(std::string* groupingkey);
+  private:
+  const std::string& _internal_groupingkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value);
+  std::string* _internal_mutable_groupingkey();
+  public:
+
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional int64 senderTimestampMs = 4;
+  bool has_sendertimestampms() const;
+  private:
+  bool _internal_has_sendertimestampms() const;
+  public:
+  void clear_sendertimestampms();
+  int64_t sendertimestampms() const;
+  void set_sendertimestampms(int64_t value);
+  private:
+  int64_t _internal_sendertimestampms() const;
+  void _internal_set_sendertimestampms(int64_t value);
+  public:
+
+  // optional bool unread = 5;
+  bool has_unread() const;
+  private:
+  bool _internal_has_unread() const;
+  public:
+  void clear_unread();
+  bool unread() const;
+  void set_unread(bool value);
+  private:
+  bool _internal_unread() const;
+  void _internal_set_unread(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.Reaction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_;
+    ::proto::MessageKey* key_;
+    int64_t sendertimestampms_;
+    bool unread_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecentEmojiWeight final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecentEmojiWeight) */ {
+ public:
+  inline RecentEmojiWeight() : RecentEmojiWeight(nullptr) {}
+  ~RecentEmojiWeight() override;
+  explicit PROTOBUF_CONSTEXPR RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RecentEmojiWeight(const RecentEmojiWeight& from);
+  RecentEmojiWeight(RecentEmojiWeight&& from) noexcept
+    : RecentEmojiWeight() {
+    *this = ::std::move(from);
+  }
+
+  inline RecentEmojiWeight& operator=(const RecentEmojiWeight& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RecentEmojiWeight& operator=(RecentEmojiWeight&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RecentEmojiWeight& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RecentEmojiWeight* internal_default_instance() {
+    return reinterpret_cast<const RecentEmojiWeight*>(
+               &_RecentEmojiWeight_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    162;
+
+  friend void swap(RecentEmojiWeight& a, RecentEmojiWeight& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RecentEmojiWeight* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RecentEmojiWeight* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RecentEmojiWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RecentEmojiWeight>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RecentEmojiWeight& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const RecentEmojiWeight& from) {
+    RecentEmojiWeight::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RecentEmojiWeight* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.RecentEmojiWeight";
+  }
+  protected:
+  explicit RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEmojiFieldNumber = 1,
+    kWeightFieldNumber = 2,
+  };
+  // optional string emoji = 1;
+  bool has_emoji() const;
+  private:
+  bool _internal_has_emoji() const;
+  public:
+  void clear_emoji();
+  const std::string& emoji() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_emoji(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_emoji();
+  PROTOBUF_NODISCARD std::string* release_emoji();
+  void set_allocated_emoji(std::string* emoji);
+  private:
+  const std::string& _internal_emoji() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_emoji(const std::string& value);
+  std::string* _internal_mutable_emoji();
+  public:
+
+  // optional float weight = 2;
+  bool has_weight() const;
+  private:
+  bool _internal_has_weight() const;
+  public:
+  void clear_weight();
+  float weight() const;
+  void set_weight(float value);
+  private:
+  float _internal_weight() const;
+  void _internal_set_weight(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.RecentEmojiWeight)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr emoji_;
+    float weight_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecordStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecordStructure) */ {
+ public:
+  inline RecordStructure() : RecordStructure(nullptr) {}
+  ~RecordStructure() override;
+  explicit PROTOBUF_CONSTEXPR RecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RecordStructure(const RecordStructure& from);
+  RecordStructure(RecordStructure&& from) noexcept
+    : RecordStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline RecordStructure& operator=(const RecordStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RecordStructure& operator=(RecordStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RecordStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RecordStructure* internal_default_instance() {
+    return reinterpret_cast<const RecordStructure*>(
+               &_RecordStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    163;
+
+  friend void swap(RecordStructure& a, RecordStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RecordStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RecordStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RecordStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RecordStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const RecordStructure& from) {
+    RecordStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RecordStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.RecordStructure";
+  }
+  protected:
+  explicit RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPreviousSessionsFieldNumber = 2,
+    kCurrentSessionFieldNumber = 1,
+  };
+  // repeated .proto.SessionStructure previousSessions = 2;
+  int previoussessions_size() const;
+  private:
+  int _internal_previoussessions_size() const;
+  public:
+  void clear_previoussessions();
+  ::proto::SessionStructure* mutable_previoussessions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >*
+      mutable_previoussessions();
+  private:
+  const ::proto::SessionStructure& _internal_previoussessions(int index) const;
+  ::proto::SessionStructure* _internal_add_previoussessions();
+  public:
+  const ::proto::SessionStructure& previoussessions(int index) const;
+  ::proto::SessionStructure* add_previoussessions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >&
+      previoussessions() const;
+
+  // optional .proto.SessionStructure currentSession = 1;
+  bool has_currentsession() const;
+  private:
+  bool _internal_has_currentsession() const;
+  public:
+  void clear_currentsession();
+  const ::proto::SessionStructure& currentsession() const;
+  PROTOBUF_NODISCARD ::proto::SessionStructure* release_currentsession();
+  ::proto::SessionStructure* mutable_currentsession();
+  void set_allocated_currentsession(::proto::SessionStructure* currentsession);
+  private:
+  const ::proto::SessionStructure& _internal_currentsession() const;
+  ::proto::SessionStructure* _internal_mutable_currentsession();
+  public:
+  void unsafe_arena_set_allocated_currentsession(
+      ::proto::SessionStructure* currentsession);
+  ::proto::SessionStructure* unsafe_arena_release_currentsession();
+
+  // @@protoc_insertion_point(class_scope:proto.RecordStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure > previoussessions_;
+    ::proto::SessionStructure* currentsession_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SenderChainKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderChainKey) */ {
+ public:
+  inline SenderChainKey() : SenderChainKey(nullptr) {}
+  ~SenderChainKey() override;
+  explicit PROTOBUF_CONSTEXPR SenderChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SenderChainKey(const SenderChainKey& from);
+  SenderChainKey(SenderChainKey&& from) noexcept
+    : SenderChainKey() {
+    *this = ::std::move(from);
+  }
+
+  inline SenderChainKey& operator=(const SenderChainKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SenderChainKey& operator=(SenderChainKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SenderChainKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SenderChainKey* internal_default_instance() {
+    return reinterpret_cast<const SenderChainKey*>(
+               &_SenderChainKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    164;
+
+  friend void swap(SenderChainKey& a, SenderChainKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SenderChainKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SenderChainKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SenderChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SenderChainKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SenderChainKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SenderChainKey& from) {
+    SenderChainKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SenderChainKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SenderChainKey";
+  }
+  protected:
+  explicit SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSeedFieldNumber = 2,
+    kIterationFieldNumber = 1,
+  };
+  // optional bytes seed = 2;
+  bool has_seed() const;
+  private:
+  bool _internal_has_seed() const;
+  public:
+  void clear_seed();
+  const std::string& seed() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_seed(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_seed();
+  PROTOBUF_NODISCARD std::string* release_seed();
+  void set_allocated_seed(std::string* seed);
+  private:
+  const std::string& _internal_seed() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value);
+  std::string* _internal_mutable_seed();
+  public:
+
+  // optional uint32 iteration = 1;
+  bool has_iteration() const;
+  private:
+  bool _internal_has_iteration() const;
+  public:
+  void clear_iteration();
+  uint32_t iteration() const;
+  void set_iteration(uint32_t value);
+  private:
+  uint32_t _internal_iteration() const;
+  void _internal_set_iteration(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SenderChainKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_;
+    uint32_t iteration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SenderKeyRecordStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyRecordStructure) */ {
+ public:
+  inline SenderKeyRecordStructure() : SenderKeyRecordStructure(nullptr) {}
+  ~SenderKeyRecordStructure() override;
+  explicit PROTOBUF_CONSTEXPR SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SenderKeyRecordStructure(const SenderKeyRecordStructure& from);
+  SenderKeyRecordStructure(SenderKeyRecordStructure&& from) noexcept
+    : SenderKeyRecordStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline SenderKeyRecordStructure& operator=(const SenderKeyRecordStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SenderKeyRecordStructure& operator=(SenderKeyRecordStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SenderKeyRecordStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SenderKeyRecordStructure* internal_default_instance() {
+    return reinterpret_cast<const SenderKeyRecordStructure*>(
+               &_SenderKeyRecordStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    165;
+
+  friend void swap(SenderKeyRecordStructure& a, SenderKeyRecordStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SenderKeyRecordStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SenderKeyRecordStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SenderKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SenderKeyRecordStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SenderKeyRecordStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SenderKeyRecordStructure& from) {
+    SenderKeyRecordStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SenderKeyRecordStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SenderKeyRecordStructure";
+  }
+  protected:
+  explicit SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSenderKeyStatesFieldNumber = 1,
+  };
+  // repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
+  int senderkeystates_size() const;
+  private:
+  int _internal_senderkeystates_size() const;
+  public:
+  void clear_senderkeystates();
+  ::proto::SenderKeyStateStructure* mutable_senderkeystates(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >*
+      mutable_senderkeystates();
+  private:
+  const ::proto::SenderKeyStateStructure& _internal_senderkeystates(int index) const;
+  ::proto::SenderKeyStateStructure* _internal_add_senderkeystates();
+  public:
+  const ::proto::SenderKeyStateStructure& senderkeystates(int index) const;
+  ::proto::SenderKeyStateStructure* add_senderkeystates();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >&
+      senderkeystates() const;
+
+  // @@protoc_insertion_point(class_scope:proto.SenderKeyRecordStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure > senderkeystates_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SenderKeyStateStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyStateStructure) */ {
+ public:
+  inline SenderKeyStateStructure() : SenderKeyStateStructure(nullptr) {}
+  ~SenderKeyStateStructure() override;
+  explicit PROTOBUF_CONSTEXPR SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SenderKeyStateStructure(const SenderKeyStateStructure& from);
+  SenderKeyStateStructure(SenderKeyStateStructure&& from) noexcept
+    : SenderKeyStateStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline SenderKeyStateStructure& operator=(const SenderKeyStateStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SenderKeyStateStructure& operator=(SenderKeyStateStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SenderKeyStateStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SenderKeyStateStructure* internal_default_instance() {
+    return reinterpret_cast<const SenderKeyStateStructure*>(
+               &_SenderKeyStateStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    166;
+
+  friend void swap(SenderKeyStateStructure& a, SenderKeyStateStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SenderKeyStateStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SenderKeyStateStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SenderKeyStateStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SenderKeyStateStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SenderKeyStateStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SenderKeyStateStructure& from) {
+    SenderKeyStateStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SenderKeyStateStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SenderKeyStateStructure";
+  }
+  protected:
+  explicit SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSenderMessageKeysFieldNumber = 4,
+    kSenderChainKeyFieldNumber = 2,
+    kSenderSigningKeyFieldNumber = 3,
+    kSenderKeyIdFieldNumber = 1,
+  };
+  // repeated .proto.SenderMessageKey senderMessageKeys = 4;
+  int sendermessagekeys_size() const;
+  private:
+  int _internal_sendermessagekeys_size() const;
+  public:
+  void clear_sendermessagekeys();
+  ::proto::SenderMessageKey* mutable_sendermessagekeys(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >*
+      mutable_sendermessagekeys();
+  private:
+  const ::proto::SenderMessageKey& _internal_sendermessagekeys(int index) const;
+  ::proto::SenderMessageKey* _internal_add_sendermessagekeys();
+  public:
+  const ::proto::SenderMessageKey& sendermessagekeys(int index) const;
+  ::proto::SenderMessageKey* add_sendermessagekeys();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >&
+      sendermessagekeys() const;
+
+  // optional .proto.SenderChainKey senderChainKey = 2;
+  bool has_senderchainkey() const;
+  private:
+  bool _internal_has_senderchainkey() const;
+  public:
+  void clear_senderchainkey();
+  const ::proto::SenderChainKey& senderchainkey() const;
+  PROTOBUF_NODISCARD ::proto::SenderChainKey* release_senderchainkey();
+  ::proto::SenderChainKey* mutable_senderchainkey();
+  void set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey);
+  private:
+  const ::proto::SenderChainKey& _internal_senderchainkey() const;
+  ::proto::SenderChainKey* _internal_mutable_senderchainkey();
+  public:
+  void unsafe_arena_set_allocated_senderchainkey(
+      ::proto::SenderChainKey* senderchainkey);
+  ::proto::SenderChainKey* unsafe_arena_release_senderchainkey();
+
+  // optional .proto.SenderSigningKey senderSigningKey = 3;
+  bool has_sendersigningkey() const;
+  private:
+  bool _internal_has_sendersigningkey() const;
+  public:
+  void clear_sendersigningkey();
+  const ::proto::SenderSigningKey& sendersigningkey() const;
+  PROTOBUF_NODISCARD ::proto::SenderSigningKey* release_sendersigningkey();
+  ::proto::SenderSigningKey* mutable_sendersigningkey();
+  void set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey);
+  private:
+  const ::proto::SenderSigningKey& _internal_sendersigningkey() const;
+  ::proto::SenderSigningKey* _internal_mutable_sendersigningkey();
+  public:
+  void unsafe_arena_set_allocated_sendersigningkey(
+      ::proto::SenderSigningKey* sendersigningkey);
+  ::proto::SenderSigningKey* unsafe_arena_release_sendersigningkey();
+
+  // optional uint32 senderKeyId = 1;
+  bool has_senderkeyid() const;
+  private:
+  bool _internal_has_senderkeyid() const;
+  public:
+  void clear_senderkeyid();
+  uint32_t senderkeyid() const;
+  void set_senderkeyid(uint32_t value);
+  private:
+  uint32_t _internal_senderkeyid() const;
+  void _internal_set_senderkeyid(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SenderKeyStateStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey > sendermessagekeys_;
+    ::proto::SenderChainKey* senderchainkey_;
+    ::proto::SenderSigningKey* sendersigningkey_;
+    uint32_t senderkeyid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SenderMessageKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderMessageKey) */ {
+ public:
+  inline SenderMessageKey() : SenderMessageKey(nullptr) {}
+  ~SenderMessageKey() override;
+  explicit PROTOBUF_CONSTEXPR SenderMessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SenderMessageKey(const SenderMessageKey& from);
+  SenderMessageKey(SenderMessageKey&& from) noexcept
+    : SenderMessageKey() {
+    *this = ::std::move(from);
+  }
+
+  inline SenderMessageKey& operator=(const SenderMessageKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SenderMessageKey& operator=(SenderMessageKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SenderMessageKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SenderMessageKey* internal_default_instance() {
+    return reinterpret_cast<const SenderMessageKey*>(
+               &_SenderMessageKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    167;
+
+  friend void swap(SenderMessageKey& a, SenderMessageKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SenderMessageKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SenderMessageKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SenderMessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SenderMessageKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SenderMessageKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SenderMessageKey& from) {
+    SenderMessageKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SenderMessageKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SenderMessageKey";
+  }
+  protected:
+  explicit SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSeedFieldNumber = 2,
+    kIterationFieldNumber = 1,
+  };
+  // optional bytes seed = 2;
+  bool has_seed() const;
+  private:
+  bool _internal_has_seed() const;
+  public:
+  void clear_seed();
+  const std::string& seed() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_seed(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_seed();
+  PROTOBUF_NODISCARD std::string* release_seed();
+  void set_allocated_seed(std::string* seed);
+  private:
+  const std::string& _internal_seed() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value);
+  std::string* _internal_mutable_seed();
+  public:
+
+  // optional uint32 iteration = 1;
+  bool has_iteration() const;
+  private:
+  bool _internal_has_iteration() const;
+  public:
+  void clear_iteration();
+  uint32_t iteration() const;
+  void set_iteration(uint32_t value);
+  private:
+  uint32_t _internal_iteration() const;
+  void _internal_set_iteration(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SenderMessageKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_;
+    uint32_t iteration_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SenderSigningKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderSigningKey) */ {
+ public:
+  inline SenderSigningKey() : SenderSigningKey(nullptr) {}
+  ~SenderSigningKey() override;
+  explicit PROTOBUF_CONSTEXPR SenderSigningKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SenderSigningKey(const SenderSigningKey& from);
+  SenderSigningKey(SenderSigningKey&& from) noexcept
+    : SenderSigningKey() {
+    *this = ::std::move(from);
+  }
+
+  inline SenderSigningKey& operator=(const SenderSigningKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SenderSigningKey& operator=(SenderSigningKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SenderSigningKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SenderSigningKey* internal_default_instance() {
+    return reinterpret_cast<const SenderSigningKey*>(
+               &_SenderSigningKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    168;
+
+  friend void swap(SenderSigningKey& a, SenderSigningKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SenderSigningKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SenderSigningKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SenderSigningKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SenderSigningKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SenderSigningKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SenderSigningKey& from) {
+    SenderSigningKey::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SenderSigningKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SenderSigningKey";
+  }
+  protected:
+  explicit SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicFieldNumber = 1,
+    kPrivateFieldNumber = 2,
+  };
+  // optional bytes public = 1;
+  bool has_public_() const;
+  private:
+  bool _internal_has_public_() const;
+  public:
+  void clear_public_();
+  const std::string& public_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_();
+  PROTOBUF_NODISCARD std::string* release_public_();
+  void set_allocated_public_(std::string* public_);
+  private:
+  const std::string& _internal_public_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_(const std::string& value);
+  std::string* _internal_mutable_public_();
+  public:
+
+  // optional bytes private = 2;
+  bool has_private_() const;
+  private:
+  bool _internal_has_private_() const;
+  public:
+  void clear_private_();
+  const std::string& private_() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_private_(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_private_();
+  PROTOBUF_NODISCARD std::string* release_private_();
+  void set_allocated_private_(std::string* private_);
+  private:
+  const std::string& _internal_private_() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_(const std::string& value);
+  std::string* _internal_mutable_private_();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SenderSigningKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public__;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private__;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ServerErrorReceipt final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ServerErrorReceipt) */ {
+ public:
+  inline ServerErrorReceipt() : ServerErrorReceipt(nullptr) {}
+  ~ServerErrorReceipt() override;
+  explicit PROTOBUF_CONSTEXPR ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ServerErrorReceipt(const ServerErrorReceipt& from);
+  ServerErrorReceipt(ServerErrorReceipt&& from) noexcept
+    : ServerErrorReceipt() {
+    *this = ::std::move(from);
+  }
+
+  inline ServerErrorReceipt& operator=(const ServerErrorReceipt& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ServerErrorReceipt& operator=(ServerErrorReceipt&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ServerErrorReceipt& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ServerErrorReceipt* internal_default_instance() {
+    return reinterpret_cast<const ServerErrorReceipt*>(
+               &_ServerErrorReceipt_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    169;
+
+  friend void swap(ServerErrorReceipt& a, ServerErrorReceipt& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ServerErrorReceipt* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ServerErrorReceipt* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ServerErrorReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ServerErrorReceipt>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ServerErrorReceipt& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ServerErrorReceipt& from) {
+    ServerErrorReceipt::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ServerErrorReceipt* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.ServerErrorReceipt";
+  }
+  protected:
+  explicit ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStanzaIdFieldNumber = 1,
+  };
+  // optional string stanzaId = 1;
+  bool has_stanzaid() const;
+  private:
+  bool _internal_has_stanzaid() const;
+  public:
+  void clear_stanzaid();
+  const std::string& stanzaid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stanzaid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stanzaid();
+  PROTOBUF_NODISCARD std::string* release_stanzaid();
+  void set_allocated_stanzaid(std::string* stanzaid);
+  private:
+  const std::string& _internal_stanzaid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
+  std::string* _internal_mutable_stanzaid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.ServerErrorReceipt)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SessionStructure) */ {
+ public:
+  inline SessionStructure() : SessionStructure(nullptr) {}
+  ~SessionStructure() override;
+  explicit PROTOBUF_CONSTEXPR SessionStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionStructure(const SessionStructure& from);
+  SessionStructure(SessionStructure&& from) noexcept
+    : SessionStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionStructure& operator=(const SessionStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionStructure& operator=(SessionStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionStructure* internal_default_instance() {
+    return reinterpret_cast<const SessionStructure*>(
+               &_SessionStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    170;
+
+  friend void swap(SessionStructure& a, SessionStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SessionStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SessionStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SessionStructure& from) {
+    SessionStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SessionStructure";
+  }
+  protected:
+  explicit SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReceiverChainsFieldNumber = 7,
+    kLocalIdentityPublicFieldNumber = 2,
+    kRemoteIdentityPublicFieldNumber = 3,
+    kRootKeyFieldNumber = 4,
+    kAliceBaseKeyFieldNumber = 13,
+    kSenderChainFieldNumber = 6,
+    kPendingKeyExchangeFieldNumber = 8,
+    kPendingPreKeyFieldNumber = 9,
+    kSessionVersionFieldNumber = 1,
+    kPreviousCounterFieldNumber = 5,
+    kRemoteRegistrationIdFieldNumber = 10,
+    kLocalRegistrationIdFieldNumber = 11,
+    kNeedsRefreshFieldNumber = 12,
+  };
+  // repeated .proto.Chain receiverChains = 7;
+  int receiverchains_size() const;
+  private:
+  int _internal_receiverchains_size() const;
+  public:
+  void clear_receiverchains();
+  ::proto::Chain* mutable_receiverchains(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >*
+      mutable_receiverchains();
+  private:
+  const ::proto::Chain& _internal_receiverchains(int index) const;
+  ::proto::Chain* _internal_add_receiverchains();
+  public:
+  const ::proto::Chain& receiverchains(int index) const;
+  ::proto::Chain* add_receiverchains();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >&
+      receiverchains() const;
+
+  // optional bytes localIdentityPublic = 2;
+  bool has_localidentitypublic() const;
+  private:
+  bool _internal_has_localidentitypublic() const;
+  public:
+  void clear_localidentitypublic();
+  const std::string& localidentitypublic() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_localidentitypublic(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_localidentitypublic();
+  PROTOBUF_NODISCARD std::string* release_localidentitypublic();
+  void set_allocated_localidentitypublic(std::string* localidentitypublic);
+  private:
+  const std::string& _internal_localidentitypublic() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitypublic(const std::string& value);
+  std::string* _internal_mutable_localidentitypublic();
+  public:
+
+  // optional bytes remoteIdentityPublic = 3;
+  bool has_remoteidentitypublic() const;
+  private:
+  bool _internal_has_remoteidentitypublic() const;
+  public:
+  void clear_remoteidentitypublic();
+  const std::string& remoteidentitypublic() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remoteidentitypublic(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remoteidentitypublic();
+  PROTOBUF_NODISCARD std::string* release_remoteidentitypublic();
+  void set_allocated_remoteidentitypublic(std::string* remoteidentitypublic);
+  private:
+  const std::string& _internal_remoteidentitypublic() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remoteidentitypublic(const std::string& value);
+  std::string* _internal_mutable_remoteidentitypublic();
+  public:
+
+  // optional bytes rootKey = 4;
+  bool has_rootkey() const;
+  private:
+  bool _internal_has_rootkey() const;
+  public:
+  void clear_rootkey();
+  const std::string& rootkey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rootkey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rootkey();
+  PROTOBUF_NODISCARD std::string* release_rootkey();
+  void set_allocated_rootkey(std::string* rootkey);
+  private:
+  const std::string& _internal_rootkey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rootkey(const std::string& value);
+  std::string* _internal_mutable_rootkey();
+  public:
+
+  // optional bytes aliceBaseKey = 13;
+  bool has_alicebasekey() const;
+  private:
+  bool _internal_has_alicebasekey() const;
+  public:
+  void clear_alicebasekey();
+  const std::string& alicebasekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_alicebasekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_alicebasekey();
+  PROTOBUF_NODISCARD std::string* release_alicebasekey();
+  void set_allocated_alicebasekey(std::string* alicebasekey);
+  private:
+  const std::string& _internal_alicebasekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alicebasekey(const std::string& value);
+  std::string* _internal_mutable_alicebasekey();
+  public:
+
+  // optional .proto.Chain senderChain = 6;
+  bool has_senderchain() const;
+  private:
+  bool _internal_has_senderchain() const;
+  public:
+  void clear_senderchain();
+  const ::proto::Chain& senderchain() const;
+  PROTOBUF_NODISCARD ::proto::Chain* release_senderchain();
+  ::proto::Chain* mutable_senderchain();
+  void set_allocated_senderchain(::proto::Chain* senderchain);
+  private:
+  const ::proto::Chain& _internal_senderchain() const;
+  ::proto::Chain* _internal_mutable_senderchain();
+  public:
+  void unsafe_arena_set_allocated_senderchain(
+      ::proto::Chain* senderchain);
+  ::proto::Chain* unsafe_arena_release_senderchain();
+
+  // optional .proto.PendingKeyExchange pendingKeyExchange = 8;
+  bool has_pendingkeyexchange() const;
+  private:
+  bool _internal_has_pendingkeyexchange() const;
+  public:
+  void clear_pendingkeyexchange();
+  const ::proto::PendingKeyExchange& pendingkeyexchange() const;
+  PROTOBUF_NODISCARD ::proto::PendingKeyExchange* release_pendingkeyexchange();
+  ::proto::PendingKeyExchange* mutable_pendingkeyexchange();
+  void set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange);
+  private:
+  const ::proto::PendingKeyExchange& _internal_pendingkeyexchange() const;
+  ::proto::PendingKeyExchange* _internal_mutable_pendingkeyexchange();
+  public:
+  void unsafe_arena_set_allocated_pendingkeyexchange(
+      ::proto::PendingKeyExchange* pendingkeyexchange);
+  ::proto::PendingKeyExchange* unsafe_arena_release_pendingkeyexchange();
+
+  // optional .proto.PendingPreKey pendingPreKey = 9;
+  bool has_pendingprekey() const;
+  private:
+  bool _internal_has_pendingprekey() const;
+  public:
+  void clear_pendingprekey();
+  const ::proto::PendingPreKey& pendingprekey() const;
+  PROTOBUF_NODISCARD ::proto::PendingPreKey* release_pendingprekey();
+  ::proto::PendingPreKey* mutable_pendingprekey();
+  void set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey);
+  private:
+  const ::proto::PendingPreKey& _internal_pendingprekey() const;
+  ::proto::PendingPreKey* _internal_mutable_pendingprekey();
+  public:
+  void unsafe_arena_set_allocated_pendingprekey(
+      ::proto::PendingPreKey* pendingprekey);
+  ::proto::PendingPreKey* unsafe_arena_release_pendingprekey();
+
+  // optional uint32 sessionVersion = 1;
+  bool has_sessionversion() const;
+  private:
+  bool _internal_has_sessionversion() const;
+  public:
+  void clear_sessionversion();
+  uint32_t sessionversion() const;
+  void set_sessionversion(uint32_t value);
+  private:
+  uint32_t _internal_sessionversion() const;
+  void _internal_set_sessionversion(uint32_t value);
+  public:
+
+  // optional uint32 previousCounter = 5;
+  bool has_previouscounter() const;
+  private:
+  bool _internal_has_previouscounter() const;
+  public:
+  void clear_previouscounter();
+  uint32_t previouscounter() const;
+  void set_previouscounter(uint32_t value);
+  private:
+  uint32_t _internal_previouscounter() const;
+  void _internal_set_previouscounter(uint32_t value);
+  public:
+
+  // optional uint32 remoteRegistrationId = 10;
+  bool has_remoteregistrationid() const;
+  private:
+  bool _internal_has_remoteregistrationid() const;
+  public:
+  void clear_remoteregistrationid();
+  uint32_t remoteregistrationid() const;
+  void set_remoteregistrationid(uint32_t value);
+  private:
+  uint32_t _internal_remoteregistrationid() const;
+  void _internal_set_remoteregistrationid(uint32_t value);
+  public:
+
+  // optional uint32 localRegistrationId = 11;
+  bool has_localregistrationid() const;
+  private:
+  bool _internal_has_localregistrationid() const;
+  public:
+  void clear_localregistrationid();
+  uint32_t localregistrationid() const;
+  void set_localregistrationid(uint32_t value);
+  private:
+  uint32_t _internal_localregistrationid() const;
+  void _internal_set_localregistrationid(uint32_t value);
+  public:
+
+  // optional bool needsRefresh = 12;
+  bool has_needsrefresh() const;
+  private:
+  bool _internal_has_needsrefresh() const;
+  public:
+  void clear_needsrefresh();
+  bool needsrefresh() const;
+  void set_needsrefresh(bool value);
+  private:
+  bool _internal_needsrefresh() const;
+  void _internal_set_needsrefresh(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SessionStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain > receiverchains_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitypublic_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remoteidentitypublic_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rootkey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alicebasekey_;
+    ::proto::Chain* senderchain_;
+    ::proto::PendingKeyExchange* pendingkeyexchange_;
+    ::proto::PendingPreKey* pendingprekey_;
+    uint32_t sessionversion_;
+    uint32_t previouscounter_;
+    uint32_t remoteregistrationid_;
+    uint32_t localregistrationid_;
+    bool needsrefresh_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedPreKeyRecordStructure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SignedPreKeyRecordStructure) */ {
+ public:
+  inline SignedPreKeyRecordStructure() : SignedPreKeyRecordStructure(nullptr) {}
+  ~SignedPreKeyRecordStructure() override;
+  explicit PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from);
+  SignedPreKeyRecordStructure(SignedPreKeyRecordStructure&& from) noexcept
+    : SignedPreKeyRecordStructure() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedPreKeyRecordStructure& operator=(const SignedPreKeyRecordStructure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedPreKeyRecordStructure& operator=(SignedPreKeyRecordStructure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedPreKeyRecordStructure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedPreKeyRecordStructure* internal_default_instance() {
+    return reinterpret_cast<const SignedPreKeyRecordStructure*>(
+               &_SignedPreKeyRecordStructure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    171;
+
+  friend void swap(SignedPreKeyRecordStructure& a, SignedPreKeyRecordStructure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedPreKeyRecordStructure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedPreKeyRecordStructure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SignedPreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SignedPreKeyRecordStructure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedPreKeyRecordStructure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SignedPreKeyRecordStructure& from) {
+    SignedPreKeyRecordStructure::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedPreKeyRecordStructure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SignedPreKeyRecordStructure";
+  }
+  protected:
+  explicit SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 2,
+    kPrivateKeyFieldNumber = 3,
+    kSignatureFieldNumber = 4,
+    kTimestampFieldNumber = 5,
+    kIdFieldNumber = 1,
+  };
+  // optional bytes publicKey = 2;
+  bool has_publickey() const;
+  private:
+  bool _internal_has_publickey() const;
+  public:
+  void clear_publickey();
+  const std::string& publickey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_publickey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_publickey();
+  PROTOBUF_NODISCARD std::string* release_publickey();
+  void set_allocated_publickey(std::string* publickey);
+  private:
+  const std::string& _internal_publickey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value);
+  std::string* _internal_mutable_publickey();
+  public:
+
+  // optional bytes privateKey = 3;
+  bool has_privatekey() const;
+  private:
+  bool _internal_has_privatekey() const;
+  public:
+  void clear_privatekey();
+  const std::string& privatekey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_privatekey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_privatekey();
+  PROTOBUF_NODISCARD std::string* release_privatekey();
+  void set_allocated_privatekey(std::string* privatekey);
+  private:
+  const std::string& _internal_privatekey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value);
+  std::string* _internal_mutable_privatekey();
+  public:
+
+  // optional bytes signature = 4;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_NODISCARD std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional fixed64 timestamp = 5;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  uint64_t timestamp() const;
+  void set_timestamp(uint64_t value);
+  private:
+  uint64_t _internal_timestamp() const;
+  void _internal_set_timestamp(uint64_t value);
+  public:
+
+  // optional uint32 id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  uint32_t id() const;
+  void set_id(uint32_t value);
+  private:
+  uint32_t _internal_id() const;
+  void _internal_set_id(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SignedPreKeyRecordStructure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+    uint64_t timestamp_;
+    uint32_t id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StatusPSA final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StatusPSA) */ {
+ public:
+  inline StatusPSA() : StatusPSA(nullptr) {}
+  ~StatusPSA() override;
+  explicit PROTOBUF_CONSTEXPR StatusPSA(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StatusPSA(const StatusPSA& from);
+  StatusPSA(StatusPSA&& from) noexcept
+    : StatusPSA() {
+    *this = ::std::move(from);
+  }
+
+  inline StatusPSA& operator=(const StatusPSA& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StatusPSA& operator=(StatusPSA&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StatusPSA& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StatusPSA* internal_default_instance() {
+    return reinterpret_cast<const StatusPSA*>(
+               &_StatusPSA_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    172;
+
+  friend void swap(StatusPSA& a, StatusPSA& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StatusPSA* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StatusPSA* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  StatusPSA* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<StatusPSA>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StatusPSA& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const StatusPSA& from) {
+    StatusPSA::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StatusPSA* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.StatusPSA";
+  }
+  protected:
+  explicit StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCampaignIdFieldNumber = 44,
+    kCampaignExpirationTimestampFieldNumber = 45,
+  };
+  // required uint64 campaignId = 44;
+  bool has_campaignid() const;
+  private:
+  bool _internal_has_campaignid() const;
+  public:
+  void clear_campaignid();
+  uint64_t campaignid() const;
+  void set_campaignid(uint64_t value);
+  private:
+  uint64_t _internal_campaignid() const;
+  void _internal_set_campaignid(uint64_t value);
+  public:
+
+  // optional uint64 campaignExpirationTimestamp = 45;
+  bool has_campaignexpirationtimestamp() const;
+  private:
+  bool _internal_has_campaignexpirationtimestamp() const;
+  public:
+  void clear_campaignexpirationtimestamp();
+  uint64_t campaignexpirationtimestamp() const;
+  void set_campaignexpirationtimestamp(uint64_t value);
+  private:
+  uint64_t _internal_campaignexpirationtimestamp() const;
+  void _internal_set_campaignexpirationtimestamp(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.StatusPSA)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint64_t campaignid_;
+    uint64_t campaignexpirationtimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StickerMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StickerMetadata) */ {
+ public:
+  inline StickerMetadata() : StickerMetadata(nullptr) {}
+  ~StickerMetadata() override;
+  explicit PROTOBUF_CONSTEXPR StickerMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StickerMetadata(const StickerMetadata& from);
+  StickerMetadata(StickerMetadata&& from) noexcept
+    : StickerMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline StickerMetadata& operator=(const StickerMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StickerMetadata& operator=(StickerMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StickerMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StickerMetadata* internal_default_instance() {
+    return reinterpret_cast<const StickerMetadata*>(
+               &_StickerMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    173;
+
+  friend void swap(StickerMetadata& a, StickerMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StickerMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StickerMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  StickerMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<StickerMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StickerMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const StickerMetadata& from) {
+    StickerMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StickerMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.StickerMetadata";
+  }
+  protected:
+  explicit StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kFileSha256FieldNumber = 2,
+    kFileEncSha256FieldNumber = 3,
+    kMediaKeyFieldNumber = 4,
+    kMimetypeFieldNumber = 5,
+    kDirectPathFieldNumber = 8,
+    kHeightFieldNumber = 6,
+    kWidthFieldNumber = 7,
+    kFileLengthFieldNumber = 9,
+    kWeightFieldNumber = 10,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional bytes fileSha256 = 2;
+  bool has_filesha256() const;
+  private:
+  bool _internal_has_filesha256() const;
+  public:
+  void clear_filesha256();
+  const std::string& filesha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filesha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filesha256();
+  PROTOBUF_NODISCARD std::string* release_filesha256();
+  void set_allocated_filesha256(std::string* filesha256);
+  private:
+  const std::string& _internal_filesha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
+  std::string* _internal_mutable_filesha256();
+  public:
+
+  // optional bytes fileEncSha256 = 3;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional bytes mediaKey = 4;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string mimetype = 5;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional string directPath = 8;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional uint32 height = 6;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional uint32 width = 7;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional uint64 fileLength = 9;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional float weight = 10;
+  bool has_weight() const;
+  private:
+  bool _internal_has_weight() const;
+  public:
+  void clear_weight();
+  float weight() const;
+  void set_weight(float value);
+  private:
+  float _internal_weight() const;
+  void _internal_set_weight(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.StickerMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    uint32_t height_;
+    uint32_t width_;
+    uint64_t filelength_;
+    float weight_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionData) */ {
+ public:
+  inline SyncActionData() : SyncActionData(nullptr) {}
+  ~SyncActionData() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionData(const SyncActionData& from);
+  SyncActionData(SyncActionData&& from) noexcept
+    : SyncActionData() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionData& operator=(const SyncActionData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionData& operator=(SyncActionData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionData* internal_default_instance() {
+    return reinterpret_cast<const SyncActionData*>(
+               &_SyncActionData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    174;
+
+  friend void swap(SyncActionData& a, SyncActionData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionData& from) {
+    SyncActionData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionData";
+  }
+  protected:
+  explicit SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndexFieldNumber = 1,
+    kPaddingFieldNumber = 3,
+    kValueFieldNumber = 2,
+    kVersionFieldNumber = 4,
+  };
+  // optional bytes index = 1;
+  bool has_index() const;
+  private:
+  bool _internal_has_index() const;
+  public:
+  void clear_index();
+  const std::string& index() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_index(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_index();
+  PROTOBUF_NODISCARD std::string* release_index();
+  void set_allocated_index(std::string* index);
+  private:
+  const std::string& _internal_index() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_index(const std::string& value);
+  std::string* _internal_mutable_index();
+  public:
+
+  // optional bytes padding = 3;
+  bool has_padding() const;
+  private:
+  bool _internal_has_padding() const;
+  public:
+  void clear_padding();
+  const std::string& padding() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_padding(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_padding();
+  PROTOBUF_NODISCARD std::string* release_padding();
+  void set_allocated_padding(std::string* padding);
+  private:
+  const std::string& _internal_padding() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_padding(const std::string& value);
+  std::string* _internal_mutable_padding();
+  public:
+
+  // optional .proto.SyncActionValue value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::proto::SyncActionValue& value() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue* release_value();
+  ::proto::SyncActionValue* mutable_value();
+  void set_allocated_value(::proto::SyncActionValue* value);
+  private:
+  const ::proto::SyncActionValue& _internal_value() const;
+  ::proto::SyncActionValue* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::proto::SyncActionValue* value);
+  ::proto::SyncActionValue* unsafe_arena_release_value();
+
+  // optional int32 version = 4;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  int32_t version() const;
+  void set_version(int32_t value);
+  private:
+  int32_t _internal_version() const;
+  void _internal_set_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr padding_;
+    ::proto::SyncActionValue* value_;
+    int32_t version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_AgentAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AgentAction) */ {
+ public:
+  inline SyncActionValue_AgentAction() : SyncActionValue_AgentAction(nullptr) {}
+  ~SyncActionValue_AgentAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from);
+  SyncActionValue_AgentAction(SyncActionValue_AgentAction&& from) noexcept
+    : SyncActionValue_AgentAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_AgentAction& operator=(const SyncActionValue_AgentAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_AgentAction& operator=(SyncActionValue_AgentAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_AgentAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_AgentAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_AgentAction*>(
+               &_SyncActionValue_AgentAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    175;
+
+  friend void swap(SyncActionValue_AgentAction& a, SyncActionValue_AgentAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_AgentAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_AgentAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_AgentAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_AgentAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_AgentAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_AgentAction& from) {
+    SyncActionValue_AgentAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_AgentAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.AgentAction";
+  }
+  protected:
+  explicit SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kDeviceIDFieldNumber = 2,
+    kIsDeletedFieldNumber = 3,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional int32 deviceID = 2;
+  bool has_deviceid() const;
+  private:
+  bool _internal_has_deviceid() const;
+  public:
+  void clear_deviceid();
+  int32_t deviceid() const;
+  void set_deviceid(int32_t value);
+  private:
+  int32_t _internal_deviceid() const;
+  void _internal_set_deviceid(int32_t value);
+  public:
+
+  // optional bool isDeleted = 3;
+  bool has_isdeleted() const;
+  private:
+  bool _internal_has_isdeleted() const;
+  public:
+  void clear_isdeleted();
+  bool isdeleted() const;
+  void set_isdeleted(bool value);
+  private:
+  bool _internal_isdeleted() const;
+  void _internal_set_isdeleted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AgentAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int32_t deviceid_;
+    bool isdeleted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_AndroidUnsupportedActions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AndroidUnsupportedActions) */ {
+ public:
+  inline SyncActionValue_AndroidUnsupportedActions() : SyncActionValue_AndroidUnsupportedActions(nullptr) {}
+  ~SyncActionValue_AndroidUnsupportedActions() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from);
+  SyncActionValue_AndroidUnsupportedActions(SyncActionValue_AndroidUnsupportedActions&& from) noexcept
+    : SyncActionValue_AndroidUnsupportedActions() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_AndroidUnsupportedActions& operator=(const SyncActionValue_AndroidUnsupportedActions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_AndroidUnsupportedActions& operator=(SyncActionValue_AndroidUnsupportedActions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_AndroidUnsupportedActions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_AndroidUnsupportedActions* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_AndroidUnsupportedActions*>(
+               &_SyncActionValue_AndroidUnsupportedActions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    176;
+
+  friend void swap(SyncActionValue_AndroidUnsupportedActions& a, SyncActionValue_AndroidUnsupportedActions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_AndroidUnsupportedActions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_AndroidUnsupportedActions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_AndroidUnsupportedActions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_AndroidUnsupportedActions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_AndroidUnsupportedActions& from) {
+    SyncActionValue_AndroidUnsupportedActions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_AndroidUnsupportedActions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.AndroidUnsupportedActions";
+  }
+  protected:
+  explicit SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllowedFieldNumber = 1,
+  };
+  // optional bool allowed = 1;
+  bool has_allowed() const;
+  private:
+  bool _internal_has_allowed() const;
+  public:
+  void clear_allowed();
+  bool allowed() const;
+  void set_allowed(bool value);
+  private:
+  bool _internal_allowed() const;
+  void _internal_set_allowed(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AndroidUnsupportedActions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool allowed_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_ArchiveChatAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ArchiveChatAction) */ {
+ public:
+  inline SyncActionValue_ArchiveChatAction() : SyncActionValue_ArchiveChatAction(nullptr) {}
+  ~SyncActionValue_ArchiveChatAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from);
+  SyncActionValue_ArchiveChatAction(SyncActionValue_ArchiveChatAction&& from) noexcept
+    : SyncActionValue_ArchiveChatAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_ArchiveChatAction& operator=(const SyncActionValue_ArchiveChatAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_ArchiveChatAction& operator=(SyncActionValue_ArchiveChatAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_ArchiveChatAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_ArchiveChatAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_ArchiveChatAction*>(
+               &_SyncActionValue_ArchiveChatAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    177;
+
+  friend void swap(SyncActionValue_ArchiveChatAction& a, SyncActionValue_ArchiveChatAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_ArchiveChatAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_ArchiveChatAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_ArchiveChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_ArchiveChatAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_ArchiveChatAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_ArchiveChatAction& from) {
+    SyncActionValue_ArchiveChatAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_ArchiveChatAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.ArchiveChatAction";
+  }
+  protected:
+  explicit SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageRangeFieldNumber = 2,
+    kArchivedFieldNumber = 1,
+  };
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+  bool has_messagerange() const;
+  private:
+  bool _internal_has_messagerange() const;
+  public:
+  void clear_messagerange();
+  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
+  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
+  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  private:
+  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
+  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
+  public:
+  void unsafe_arena_set_allocated_messagerange(
+      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();
+
+  // optional bool archived = 1;
+  bool has_archived() const;
+  private:
+  bool _internal_has_archived() const;
+  public:
+  void clear_archived();
+  bool archived() const;
+  void set_archived(bool value);
+  private:
+  bool _internal_archived() const;
+  void _internal_set_archived(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ArchiveChatAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
+    bool archived_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_ClearChatAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ClearChatAction) */ {
+ public:
+  inline SyncActionValue_ClearChatAction() : SyncActionValue_ClearChatAction(nullptr) {}
+  ~SyncActionValue_ClearChatAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from);
+  SyncActionValue_ClearChatAction(SyncActionValue_ClearChatAction&& from) noexcept
+    : SyncActionValue_ClearChatAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_ClearChatAction& operator=(const SyncActionValue_ClearChatAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_ClearChatAction& operator=(SyncActionValue_ClearChatAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_ClearChatAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_ClearChatAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_ClearChatAction*>(
+               &_SyncActionValue_ClearChatAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    178;
+
+  friend void swap(SyncActionValue_ClearChatAction& a, SyncActionValue_ClearChatAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_ClearChatAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_ClearChatAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_ClearChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_ClearChatAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_ClearChatAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_ClearChatAction& from) {
+    SyncActionValue_ClearChatAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_ClearChatAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.ClearChatAction";
+  }
+  protected:
+  explicit SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageRangeFieldNumber = 1,
+  };
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  bool has_messagerange() const;
+  private:
+  bool _internal_has_messagerange() const;
+  public:
+  void clear_messagerange();
+  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
+  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
+  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  private:
+  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
+  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
+  public:
+  void unsafe_arena_set_allocated_messagerange(
+      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ClearChatAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_ContactAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ContactAction) */ {
+ public:
+  inline SyncActionValue_ContactAction() : SyncActionValue_ContactAction(nullptr) {}
+  ~SyncActionValue_ContactAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from);
+  SyncActionValue_ContactAction(SyncActionValue_ContactAction&& from) noexcept
+    : SyncActionValue_ContactAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_ContactAction& operator=(const SyncActionValue_ContactAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_ContactAction& operator=(SyncActionValue_ContactAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_ContactAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_ContactAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_ContactAction*>(
+               &_SyncActionValue_ContactAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    179;
+
+  friend void swap(SyncActionValue_ContactAction& a, SyncActionValue_ContactAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_ContactAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_ContactAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_ContactAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_ContactAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_ContactAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_ContactAction& from) {
+    SyncActionValue_ContactAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_ContactAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.ContactAction";
+  }
+  protected:
+  explicit SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFullNameFieldNumber = 1,
+    kFirstNameFieldNumber = 2,
+  };
+  // optional string fullName = 1;
+  bool has_fullname() const;
+  private:
+  bool _internal_has_fullname() const;
+  public:
+  void clear_fullname();
+  const std::string& fullname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fullname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fullname();
+  PROTOBUF_NODISCARD std::string* release_fullname();
+  void set_allocated_fullname(std::string* fullname);
+  private:
+  const std::string& _internal_fullname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fullname(const std::string& value);
+  std::string* _internal_mutable_fullname();
+  public:
+
+  // optional string firstName = 2;
+  bool has_firstname() const;
+  private:
+  bool _internal_has_firstname() const;
+  public:
+  void clear_firstname();
+  const std::string& firstname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_firstname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_firstname();
+  PROTOBUF_NODISCARD std::string* release_firstname();
+  void set_allocated_firstname(std::string* firstname);
+  private:
+  const std::string& _internal_firstname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstname(const std::string& value);
+  std::string* _internal_mutable_firstname();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ContactAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fullname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstname_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_DeleteChatAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteChatAction) */ {
+ public:
+  inline SyncActionValue_DeleteChatAction() : SyncActionValue_DeleteChatAction(nullptr) {}
+  ~SyncActionValue_DeleteChatAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from);
+  SyncActionValue_DeleteChatAction(SyncActionValue_DeleteChatAction&& from) noexcept
+    : SyncActionValue_DeleteChatAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_DeleteChatAction& operator=(const SyncActionValue_DeleteChatAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_DeleteChatAction& operator=(SyncActionValue_DeleteChatAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_DeleteChatAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_DeleteChatAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_DeleteChatAction*>(
+               &_SyncActionValue_DeleteChatAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    180;
+
+  friend void swap(SyncActionValue_DeleteChatAction& a, SyncActionValue_DeleteChatAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_DeleteChatAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_DeleteChatAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_DeleteChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_DeleteChatAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_DeleteChatAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_DeleteChatAction& from) {
+    SyncActionValue_DeleteChatAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_DeleteChatAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.DeleteChatAction";
+  }
+  protected:
+  explicit SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageRangeFieldNumber = 1,
+  };
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+  bool has_messagerange() const;
+  private:
+  bool _internal_has_messagerange() const;
+  public:
+  void clear_messagerange();
+  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
+  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
+  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  private:
+  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
+  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
+  public:
+  void unsafe_arena_set_allocated_messagerange(
+      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteChatAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_DeleteMessageForMeAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteMessageForMeAction) */ {
+ public:
+  inline SyncActionValue_DeleteMessageForMeAction() : SyncActionValue_DeleteMessageForMeAction(nullptr) {}
+  ~SyncActionValue_DeleteMessageForMeAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from);
+  SyncActionValue_DeleteMessageForMeAction(SyncActionValue_DeleteMessageForMeAction&& from) noexcept
+    : SyncActionValue_DeleteMessageForMeAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_DeleteMessageForMeAction& operator=(const SyncActionValue_DeleteMessageForMeAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_DeleteMessageForMeAction& operator=(SyncActionValue_DeleteMessageForMeAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_DeleteMessageForMeAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_DeleteMessageForMeAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_DeleteMessageForMeAction*>(
+               &_SyncActionValue_DeleteMessageForMeAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    181;
+
+  friend void swap(SyncActionValue_DeleteMessageForMeAction& a, SyncActionValue_DeleteMessageForMeAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_DeleteMessageForMeAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_DeleteMessageForMeAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_DeleteMessageForMeAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_DeleteMessageForMeAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_DeleteMessageForMeAction& from) {
+    SyncActionValue_DeleteMessageForMeAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_DeleteMessageForMeAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.DeleteMessageForMeAction";
+  }
+  protected:
+  explicit SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageTimestampFieldNumber = 2,
+    kDeleteMediaFieldNumber = 1,
+  };
+  // optional int64 messageTimestamp = 2;
+  bool has_messagetimestamp() const;
+  private:
+  bool _internal_has_messagetimestamp() const;
+  public:
+  void clear_messagetimestamp();
+  int64_t messagetimestamp() const;
+  void set_messagetimestamp(int64_t value);
+  private:
+  int64_t _internal_messagetimestamp() const;
+  void _internal_set_messagetimestamp(int64_t value);
+  public:
+
+  // optional bool deleteMedia = 1;
+  bool has_deletemedia() const;
+  private:
+  bool _internal_has_deletemedia() const;
+  public:
+  void clear_deletemedia();
+  bool deletemedia() const;
+  void set_deletemedia(bool value);
+  private:
+  bool _internal_deletemedia() const;
+  void _internal_set_deletemedia(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteMessageForMeAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t messagetimestamp_;
+    bool deletemedia_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_KeyExpiration final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.KeyExpiration) */ {
+ public:
+  inline SyncActionValue_KeyExpiration() : SyncActionValue_KeyExpiration(nullptr) {}
+  ~SyncActionValue_KeyExpiration() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from);
+  SyncActionValue_KeyExpiration(SyncActionValue_KeyExpiration&& from) noexcept
+    : SyncActionValue_KeyExpiration() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_KeyExpiration& operator=(const SyncActionValue_KeyExpiration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_KeyExpiration& operator=(SyncActionValue_KeyExpiration&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_KeyExpiration& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_KeyExpiration* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_KeyExpiration*>(
+               &_SyncActionValue_KeyExpiration_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    182;
+
+  friend void swap(SyncActionValue_KeyExpiration& a, SyncActionValue_KeyExpiration& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_KeyExpiration* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_KeyExpiration* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_KeyExpiration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_KeyExpiration>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_KeyExpiration& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_KeyExpiration& from) {
+    SyncActionValue_KeyExpiration::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_KeyExpiration* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.KeyExpiration";
+  }
+  protected:
+  explicit SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpiredKeyEpochFieldNumber = 1,
+  };
+  // optional int32 expiredKeyEpoch = 1;
+  bool has_expiredkeyepoch() const;
+  private:
+  bool _internal_has_expiredkeyepoch() const;
+  public:
+  void clear_expiredkeyepoch();
+  int32_t expiredkeyepoch() const;
+  void set_expiredkeyepoch(int32_t value);
+  private:
+  int32_t _internal_expiredkeyepoch() const;
+  void _internal_set_expiredkeyepoch(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.KeyExpiration)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t expiredkeyepoch_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_LabelAssociationAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelAssociationAction) */ {
+ public:
+  inline SyncActionValue_LabelAssociationAction() : SyncActionValue_LabelAssociationAction(nullptr) {}
+  ~SyncActionValue_LabelAssociationAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from);
+  SyncActionValue_LabelAssociationAction(SyncActionValue_LabelAssociationAction&& from) noexcept
+    : SyncActionValue_LabelAssociationAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_LabelAssociationAction& operator=(const SyncActionValue_LabelAssociationAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_LabelAssociationAction& operator=(SyncActionValue_LabelAssociationAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_LabelAssociationAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_LabelAssociationAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_LabelAssociationAction*>(
+               &_SyncActionValue_LabelAssociationAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    183;
+
+  friend void swap(SyncActionValue_LabelAssociationAction& a, SyncActionValue_LabelAssociationAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_LabelAssociationAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_LabelAssociationAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_LabelAssociationAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_LabelAssociationAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_LabelAssociationAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_LabelAssociationAction& from) {
+    SyncActionValue_LabelAssociationAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_LabelAssociationAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.LabelAssociationAction";
+  }
+  protected:
+  explicit SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLabeledFieldNumber = 1,
+  };
+  // optional bool labeled = 1;
+  bool has_labeled() const;
+  private:
+  bool _internal_has_labeled() const;
+  public:
+  void clear_labeled();
+  bool labeled() const;
+  void set_labeled(bool value);
+  private:
+  bool _internal_labeled() const;
+  void _internal_set_labeled(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelAssociationAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool labeled_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_LabelEditAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelEditAction) */ {
+ public:
+  inline SyncActionValue_LabelEditAction() : SyncActionValue_LabelEditAction(nullptr) {}
+  ~SyncActionValue_LabelEditAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from);
+  SyncActionValue_LabelEditAction(SyncActionValue_LabelEditAction&& from) noexcept
+    : SyncActionValue_LabelEditAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_LabelEditAction& operator=(const SyncActionValue_LabelEditAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_LabelEditAction& operator=(SyncActionValue_LabelEditAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_LabelEditAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_LabelEditAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_LabelEditAction*>(
+               &_SyncActionValue_LabelEditAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    184;
+
+  friend void swap(SyncActionValue_LabelEditAction& a, SyncActionValue_LabelEditAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_LabelEditAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_LabelEditAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_LabelEditAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_LabelEditAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_LabelEditAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_LabelEditAction& from) {
+    SyncActionValue_LabelEditAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_LabelEditAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.LabelEditAction";
+  }
+  protected:
+  explicit SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kColorFieldNumber = 2,
+    kPredefinedIdFieldNumber = 3,
+    kDeletedFieldNumber = 4,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional int32 color = 2;
+  bool has_color() const;
+  private:
+  bool _internal_has_color() const;
+  public:
+  void clear_color();
+  int32_t color() const;
+  void set_color(int32_t value);
+  private:
+  int32_t _internal_color() const;
+  void _internal_set_color(int32_t value);
+  public:
+
+  // optional int32 predefinedId = 3;
+  bool has_predefinedid() const;
+  private:
+  bool _internal_has_predefinedid() const;
+  public:
+  void clear_predefinedid();
+  int32_t predefinedid() const;
+  void set_predefinedid(int32_t value);
+  private:
+  int32_t _internal_predefinedid() const;
+  void _internal_set_predefinedid(int32_t value);
+  public:
+
+  // optional bool deleted = 4;
+  bool has_deleted() const;
+  private:
+  bool _internal_has_deleted() const;
+  public:
+  void clear_deleted();
+  bool deleted() const;
+  void set_deleted(bool value);
+  private:
+  bool _internal_deleted() const;
+  void _internal_set_deleted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelEditAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int32_t color_;
+    int32_t predefinedid_;
+    bool deleted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_LocaleSetting final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LocaleSetting) */ {
+ public:
+  inline SyncActionValue_LocaleSetting() : SyncActionValue_LocaleSetting(nullptr) {}
+  ~SyncActionValue_LocaleSetting() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from);
+  SyncActionValue_LocaleSetting(SyncActionValue_LocaleSetting&& from) noexcept
+    : SyncActionValue_LocaleSetting() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_LocaleSetting& operator=(const SyncActionValue_LocaleSetting& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_LocaleSetting& operator=(SyncActionValue_LocaleSetting&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_LocaleSetting& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_LocaleSetting* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_LocaleSetting*>(
+               &_SyncActionValue_LocaleSetting_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    185;
+
+  friend void swap(SyncActionValue_LocaleSetting& a, SyncActionValue_LocaleSetting& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_LocaleSetting* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_LocaleSetting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_LocaleSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_LocaleSetting>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_LocaleSetting& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_LocaleSetting& from) {
+    SyncActionValue_LocaleSetting::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_LocaleSetting* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.LocaleSetting";
+  }
+  protected:
+  explicit SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLocaleFieldNumber = 1,
+  };
+  // optional string locale = 1;
+  bool has_locale() const;
+  private:
+  bool _internal_has_locale() const;
+  public:
+  void clear_locale();
+  const std::string& locale() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_locale(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_locale();
+  PROTOBUF_NODISCARD std::string* release_locale();
+  void set_allocated_locale(std::string* locale);
+  private:
+  const std::string& _internal_locale() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value);
+  std::string* _internal_mutable_locale();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LocaleSetting)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr locale_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_MarkChatAsReadAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MarkChatAsReadAction) */ {
+ public:
+  inline SyncActionValue_MarkChatAsReadAction() : SyncActionValue_MarkChatAsReadAction(nullptr) {}
+  ~SyncActionValue_MarkChatAsReadAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from);
+  SyncActionValue_MarkChatAsReadAction(SyncActionValue_MarkChatAsReadAction&& from) noexcept
+    : SyncActionValue_MarkChatAsReadAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_MarkChatAsReadAction& operator=(const SyncActionValue_MarkChatAsReadAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_MarkChatAsReadAction& operator=(SyncActionValue_MarkChatAsReadAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_MarkChatAsReadAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_MarkChatAsReadAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_MarkChatAsReadAction*>(
+               &_SyncActionValue_MarkChatAsReadAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    186;
+
+  friend void swap(SyncActionValue_MarkChatAsReadAction& a, SyncActionValue_MarkChatAsReadAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_MarkChatAsReadAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_MarkChatAsReadAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_MarkChatAsReadAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_MarkChatAsReadAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_MarkChatAsReadAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_MarkChatAsReadAction& from) {
+    SyncActionValue_MarkChatAsReadAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_MarkChatAsReadAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.MarkChatAsReadAction";
+  }
+  protected:
+  explicit SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageRangeFieldNumber = 2,
+    kReadFieldNumber = 1,
+  };
+  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+  bool has_messagerange() const;
+  private:
+  bool _internal_has_messagerange() const;
+  public:
+  void clear_messagerange();
+  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
+  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
+  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  private:
+  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
+  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
+  public:
+  void unsafe_arena_set_allocated_messagerange(
+      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
+  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();
+
+  // optional bool read = 1;
+  bool has_read() const;
+  private:
+  bool _internal_has_read() const;
+  public:
+  void clear_read();
+  bool read() const;
+  void set_read(bool value);
+  private:
+  bool _internal_read() const;
+  void _internal_set_read(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MarkChatAsReadAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
+    bool read_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_MuteAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MuteAction) */ {
+ public:
+  inline SyncActionValue_MuteAction() : SyncActionValue_MuteAction(nullptr) {}
+  ~SyncActionValue_MuteAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from);
+  SyncActionValue_MuteAction(SyncActionValue_MuteAction&& from) noexcept
+    : SyncActionValue_MuteAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_MuteAction& operator=(const SyncActionValue_MuteAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_MuteAction& operator=(SyncActionValue_MuteAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_MuteAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_MuteAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_MuteAction*>(
+               &_SyncActionValue_MuteAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    187;
+
+  friend void swap(SyncActionValue_MuteAction& a, SyncActionValue_MuteAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_MuteAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_MuteAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_MuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_MuteAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_MuteAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_MuteAction& from) {
+    SyncActionValue_MuteAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_MuteAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.MuteAction";
+  }
+  protected:
+  explicit SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMuteEndTimestampFieldNumber = 2,
+    kMutedFieldNumber = 1,
+  };
+  // optional int64 muteEndTimestamp = 2;
+  bool has_muteendtimestamp() const;
+  private:
+  bool _internal_has_muteendtimestamp() const;
+  public:
+  void clear_muteendtimestamp();
+  int64_t muteendtimestamp() const;
+  void set_muteendtimestamp(int64_t value);
+  private:
+  int64_t _internal_muteendtimestamp() const;
+  void _internal_set_muteendtimestamp(int64_t value);
+  public:
+
+  // optional bool muted = 1;
+  bool has_muted() const;
+  private:
+  bool _internal_has_muted() const;
+  public:
+  void clear_muted();
+  bool muted() const;
+  void set_muted(bool value);
+  private:
+  bool _internal_muted() const;
+  void _internal_set_muted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MuteAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t muteendtimestamp_;
+    bool muted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_NuxAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.NuxAction) */ {
+ public:
+  inline SyncActionValue_NuxAction() : SyncActionValue_NuxAction(nullptr) {}
+  ~SyncActionValue_NuxAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from);
+  SyncActionValue_NuxAction(SyncActionValue_NuxAction&& from) noexcept
+    : SyncActionValue_NuxAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_NuxAction& operator=(const SyncActionValue_NuxAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_NuxAction& operator=(SyncActionValue_NuxAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_NuxAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_NuxAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_NuxAction*>(
+               &_SyncActionValue_NuxAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    188;
+
+  friend void swap(SyncActionValue_NuxAction& a, SyncActionValue_NuxAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_NuxAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_NuxAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_NuxAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_NuxAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_NuxAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_NuxAction& from) {
+    SyncActionValue_NuxAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_NuxAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.NuxAction";
+  }
+  protected:
+  explicit SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAcknowledgedFieldNumber = 1,
+  };
+  // optional bool acknowledged = 1;
+  bool has_acknowledged() const;
+  private:
+  bool _internal_has_acknowledged() const;
+  public:
+  void clear_acknowledged();
+  bool acknowledged() const;
+  void set_acknowledged(bool value);
+  private:
+  bool _internal_acknowledged() const;
+  void _internal_set_acknowledged(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.NuxAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool acknowledged_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_PinAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PinAction) */ {
+ public:
+  inline SyncActionValue_PinAction() : SyncActionValue_PinAction(nullptr) {}
+  ~SyncActionValue_PinAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_PinAction(const SyncActionValue_PinAction& from);
+  SyncActionValue_PinAction(SyncActionValue_PinAction&& from) noexcept
+    : SyncActionValue_PinAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_PinAction& operator=(const SyncActionValue_PinAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_PinAction& operator=(SyncActionValue_PinAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_PinAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_PinAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_PinAction*>(
+               &_SyncActionValue_PinAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    189;
+
+  friend void swap(SyncActionValue_PinAction& a, SyncActionValue_PinAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_PinAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_PinAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_PinAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_PinAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_PinAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_PinAction& from) {
+    SyncActionValue_PinAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_PinAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.PinAction";
+  }
+  protected:
+  explicit SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPinnedFieldNumber = 1,
+  };
+  // optional bool pinned = 1;
+  bool has_pinned() const;
+  private:
+  bool _internal_has_pinned() const;
+  public:
+  void clear_pinned();
+  bool pinned() const;
+  void set_pinned(bool value);
+  private:
+  bool _internal_pinned() const;
+  void _internal_set_pinned(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PinAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool pinned_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_PrimaryFeature final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryFeature) */ {
+ public:
+  inline SyncActionValue_PrimaryFeature() : SyncActionValue_PrimaryFeature(nullptr) {}
+  ~SyncActionValue_PrimaryFeature() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from);
+  SyncActionValue_PrimaryFeature(SyncActionValue_PrimaryFeature&& from) noexcept
+    : SyncActionValue_PrimaryFeature() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_PrimaryFeature& operator=(const SyncActionValue_PrimaryFeature& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_PrimaryFeature& operator=(SyncActionValue_PrimaryFeature&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_PrimaryFeature& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_PrimaryFeature* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_PrimaryFeature*>(
+               &_SyncActionValue_PrimaryFeature_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    190;
+
+  friend void swap(SyncActionValue_PrimaryFeature& a, SyncActionValue_PrimaryFeature& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_PrimaryFeature* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_PrimaryFeature* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_PrimaryFeature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_PrimaryFeature>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_PrimaryFeature& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_PrimaryFeature& from) {
+    SyncActionValue_PrimaryFeature::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_PrimaryFeature* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.PrimaryFeature";
+  }
+  protected:
+  explicit SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFlagsFieldNumber = 1,
+  };
+  // repeated string flags = 1;
+  int flags_size() const;
+  private:
+  int _internal_flags_size() const;
+  public:
+  void clear_flags();
+  const std::string& flags(int index) const;
+  std::string* mutable_flags(int index);
+  void set_flags(int index, const std::string& value);
+  void set_flags(int index, std::string&& value);
+  void set_flags(int index, const char* value);
+  void set_flags(int index, const char* value, size_t size);
+  std::string* add_flags();
+  void add_flags(const std::string& value);
+  void add_flags(std::string&& value);
+  void add_flags(const char* value);
+  void add_flags(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& flags() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_flags();
+  private:
+  const std::string& _internal_flags(int index) const;
+  std::string* _internal_add_flags();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryFeature)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> flags_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_PrimaryVersionAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryVersionAction) */ {
+ public:
+  inline SyncActionValue_PrimaryVersionAction() : SyncActionValue_PrimaryVersionAction(nullptr) {}
+  ~SyncActionValue_PrimaryVersionAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from);
+  SyncActionValue_PrimaryVersionAction(SyncActionValue_PrimaryVersionAction&& from) noexcept
+    : SyncActionValue_PrimaryVersionAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_PrimaryVersionAction& operator=(const SyncActionValue_PrimaryVersionAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_PrimaryVersionAction& operator=(SyncActionValue_PrimaryVersionAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_PrimaryVersionAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_PrimaryVersionAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_PrimaryVersionAction*>(
+               &_SyncActionValue_PrimaryVersionAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    191;
+
+  friend void swap(SyncActionValue_PrimaryVersionAction& a, SyncActionValue_PrimaryVersionAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_PrimaryVersionAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_PrimaryVersionAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_PrimaryVersionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_PrimaryVersionAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_PrimaryVersionAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_PrimaryVersionAction& from) {
+    SyncActionValue_PrimaryVersionAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_PrimaryVersionAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.PrimaryVersionAction";
+  }
+  protected:
+  explicit SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVersionFieldNumber = 1,
+  };
+  // optional string version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryVersionAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_PushNameSetting final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PushNameSetting) */ {
+ public:
+  inline SyncActionValue_PushNameSetting() : SyncActionValue_PushNameSetting(nullptr) {}
+  ~SyncActionValue_PushNameSetting() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from);
+  SyncActionValue_PushNameSetting(SyncActionValue_PushNameSetting&& from) noexcept
+    : SyncActionValue_PushNameSetting() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_PushNameSetting& operator=(const SyncActionValue_PushNameSetting& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_PushNameSetting& operator=(SyncActionValue_PushNameSetting&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_PushNameSetting& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_PushNameSetting* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_PushNameSetting*>(
+               &_SyncActionValue_PushNameSetting_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    192;
+
+  friend void swap(SyncActionValue_PushNameSetting& a, SyncActionValue_PushNameSetting& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_PushNameSetting* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_PushNameSetting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_PushNameSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_PushNameSetting>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_PushNameSetting& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_PushNameSetting& from) {
+    SyncActionValue_PushNameSetting::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_PushNameSetting* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.PushNameSetting";
+  }
+  protected:
+  explicit SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PushNameSetting)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_QuickReplyAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.QuickReplyAction) */ {
+ public:
+  inline SyncActionValue_QuickReplyAction() : SyncActionValue_QuickReplyAction(nullptr) {}
+  ~SyncActionValue_QuickReplyAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from);
+  SyncActionValue_QuickReplyAction(SyncActionValue_QuickReplyAction&& from) noexcept
+    : SyncActionValue_QuickReplyAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_QuickReplyAction& operator=(const SyncActionValue_QuickReplyAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_QuickReplyAction& operator=(SyncActionValue_QuickReplyAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_QuickReplyAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_QuickReplyAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_QuickReplyAction*>(
+               &_SyncActionValue_QuickReplyAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    193;
+
+  friend void swap(SyncActionValue_QuickReplyAction& a, SyncActionValue_QuickReplyAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_QuickReplyAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_QuickReplyAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_QuickReplyAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_QuickReplyAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_QuickReplyAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_QuickReplyAction& from) {
+    SyncActionValue_QuickReplyAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_QuickReplyAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.QuickReplyAction";
+  }
+  protected:
+  explicit SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeywordsFieldNumber = 3,
+    kShortcutFieldNumber = 1,
+    kMessageFieldNumber = 2,
+    kCountFieldNumber = 4,
+    kDeletedFieldNumber = 5,
+  };
+  // repeated string keywords = 3;
+  int keywords_size() const;
+  private:
+  int _internal_keywords_size() const;
+  public:
+  void clear_keywords();
+  const std::string& keywords(int index) const;
+  std::string* mutable_keywords(int index);
+  void set_keywords(int index, const std::string& value);
+  void set_keywords(int index, std::string&& value);
+  void set_keywords(int index, const char* value);
+  void set_keywords(int index, const char* value, size_t size);
+  std::string* add_keywords();
+  void add_keywords(const std::string& value);
+  void add_keywords(std::string&& value);
+  void add_keywords(const char* value);
+  void add_keywords(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& keywords() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_keywords();
+  private:
+  const std::string& _internal_keywords(int index) const;
+  std::string* _internal_add_keywords();
+  public:
+
+  // optional string shortcut = 1;
+  bool has_shortcut() const;
+  private:
+  bool _internal_has_shortcut() const;
+  public:
+  void clear_shortcut();
+  const std::string& shortcut() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_shortcut(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_shortcut();
+  PROTOBUF_NODISCARD std::string* release_shortcut();
+  void set_allocated_shortcut(std::string* shortcut);
+  private:
+  const std::string& _internal_shortcut() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_shortcut(const std::string& value);
+  std::string* _internal_mutable_shortcut();
+  public:
+
+  // optional string message = 2;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const std::string& message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_message();
+  PROTOBUF_NODISCARD std::string* release_message();
+  void set_allocated_message(std::string* message);
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+  std::string* _internal_mutable_message();
+  public:
+
+  // optional int32 count = 4;
+  bool has_count() const;
+  private:
+  bool _internal_has_count() const;
+  public:
+  void clear_count();
+  int32_t count() const;
+  void set_count(int32_t value);
+  private:
+  int32_t _internal_count() const;
+  void _internal_set_count(int32_t value);
+  public:
+
+  // optional bool deleted = 5;
+  bool has_deleted() const;
+  private:
+  bool _internal_has_deleted() const;
+  public:
+  void clear_deleted();
+  bool deleted() const;
+  void set_deleted(bool value);
+  private:
+  bool _internal_deleted() const;
+  void _internal_set_deleted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.QuickReplyAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> keywords_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortcut_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+    int32_t count_;
+    bool deleted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_RecentEmojiWeightsAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.RecentEmojiWeightsAction) */ {
+ public:
+  inline SyncActionValue_RecentEmojiWeightsAction() : SyncActionValue_RecentEmojiWeightsAction(nullptr) {}
+  ~SyncActionValue_RecentEmojiWeightsAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from);
+  SyncActionValue_RecentEmojiWeightsAction(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept
+    : SyncActionValue_RecentEmojiWeightsAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_RecentEmojiWeightsAction& operator=(const SyncActionValue_RecentEmojiWeightsAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_RecentEmojiWeightsAction& operator=(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_RecentEmojiWeightsAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_RecentEmojiWeightsAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_RecentEmojiWeightsAction*>(
+               &_SyncActionValue_RecentEmojiWeightsAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    194;
+
+  friend void swap(SyncActionValue_RecentEmojiWeightsAction& a, SyncActionValue_RecentEmojiWeightsAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_RecentEmojiWeightsAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_RecentEmojiWeightsAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_RecentEmojiWeightsAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_RecentEmojiWeightsAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_RecentEmojiWeightsAction& from) {
+    SyncActionValue_RecentEmojiWeightsAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.RecentEmojiWeightsAction";
+  }
+  protected:
+  explicit SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWeightsFieldNumber = 1,
+  };
+  // repeated .proto.RecentEmojiWeight weights = 1;
+  int weights_size() const;
+  private:
+  int _internal_weights_size() const;
+  public:
+  void clear_weights();
+  ::proto::RecentEmojiWeight* mutable_weights(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >*
+      mutable_weights();
+  private:
+  const ::proto::RecentEmojiWeight& _internal_weights(int index) const;
+  ::proto::RecentEmojiWeight* _internal_add_weights();
+  public:
+  const ::proto::RecentEmojiWeight& weights(int index) const;
+  ::proto::RecentEmojiWeight* add_weights();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >&
+      weights() const;
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.RecentEmojiWeightsAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight > weights_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_SecurityNotificationSetting final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SecurityNotificationSetting) */ {
+ public:
+  inline SyncActionValue_SecurityNotificationSetting() : SyncActionValue_SecurityNotificationSetting(nullptr) {}
+  ~SyncActionValue_SecurityNotificationSetting() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from);
+  SyncActionValue_SecurityNotificationSetting(SyncActionValue_SecurityNotificationSetting&& from) noexcept
+    : SyncActionValue_SecurityNotificationSetting() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_SecurityNotificationSetting& operator=(const SyncActionValue_SecurityNotificationSetting& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_SecurityNotificationSetting& operator=(SyncActionValue_SecurityNotificationSetting&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_SecurityNotificationSetting& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_SecurityNotificationSetting* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_SecurityNotificationSetting*>(
+               &_SyncActionValue_SecurityNotificationSetting_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    195;
+
+  friend void swap(SyncActionValue_SecurityNotificationSetting& a, SyncActionValue_SecurityNotificationSetting& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_SecurityNotificationSetting* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_SecurityNotificationSetting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_SecurityNotificationSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_SecurityNotificationSetting>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_SecurityNotificationSetting& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_SecurityNotificationSetting& from) {
+    SyncActionValue_SecurityNotificationSetting::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_SecurityNotificationSetting* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.SecurityNotificationSetting";
+  }
+  protected:
+  explicit SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShowNotificationFieldNumber = 1,
+  };
+  // optional bool showNotification = 1;
+  bool has_shownotification() const;
+  private:
+  bool _internal_has_shownotification() const;
+  public:
+  void clear_shownotification();
+  bool shownotification() const;
+  void set_shownotification(bool value);
+  private:
+  bool _internal_shownotification() const;
+  void _internal_set_shownotification(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SecurityNotificationSetting)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool shownotification_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_StarAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StarAction) */ {
+ public:
+  inline SyncActionValue_StarAction() : SyncActionValue_StarAction(nullptr) {}
+  ~SyncActionValue_StarAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_StarAction(const SyncActionValue_StarAction& from);
+  SyncActionValue_StarAction(SyncActionValue_StarAction&& from) noexcept
+    : SyncActionValue_StarAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_StarAction& operator=(const SyncActionValue_StarAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_StarAction& operator=(SyncActionValue_StarAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_StarAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_StarAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_StarAction*>(
+               &_SyncActionValue_StarAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    196;
+
+  friend void swap(SyncActionValue_StarAction& a, SyncActionValue_StarAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_StarAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_StarAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_StarAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_StarAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_StarAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_StarAction& from) {
+    SyncActionValue_StarAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_StarAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.StarAction";
+  }
+  protected:
+  explicit SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStarredFieldNumber = 1,
+  };
+  // optional bool starred = 1;
+  bool has_starred() const;
+  private:
+  bool _internal_has_starred() const;
+  public:
+  void clear_starred();
+  bool starred() const;
+  void set_starred(bool value);
+  private:
+  bool _internal_starred() const;
+  void _internal_set_starred(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StarAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool starred_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_StickerAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StickerAction) */ {
+ public:
+  inline SyncActionValue_StickerAction() : SyncActionValue_StickerAction(nullptr) {}
+  ~SyncActionValue_StickerAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from);
+  SyncActionValue_StickerAction(SyncActionValue_StickerAction&& from) noexcept
+    : SyncActionValue_StickerAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_StickerAction& operator=(const SyncActionValue_StickerAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_StickerAction& operator=(SyncActionValue_StickerAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_StickerAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_StickerAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_StickerAction*>(
+               &_SyncActionValue_StickerAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    197;
+
+  friend void swap(SyncActionValue_StickerAction& a, SyncActionValue_StickerAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_StickerAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_StickerAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_StickerAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_StickerAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_StickerAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_StickerAction& from) {
+    SyncActionValue_StickerAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_StickerAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.StickerAction";
+  }
+  protected:
+  explicit SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kFileEncSha256FieldNumber = 2,
+    kMediaKeyFieldNumber = 3,
+    kMimetypeFieldNumber = 4,
+    kDirectPathFieldNumber = 7,
+    kHeightFieldNumber = 5,
+    kWidthFieldNumber = 6,
+    kFileLengthFieldNumber = 8,
+    kIsFavoriteFieldNumber = 9,
+    kDeviceIdHintFieldNumber = 10,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional bytes fileEncSha256 = 2;
+  bool has_fileencsha256() const;
+  private:
+  bool _internal_has_fileencsha256() const;
+  public:
+  void clear_fileencsha256();
+  const std::string& fileencsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fileencsha256();
+  PROTOBUF_NODISCARD std::string* release_fileencsha256();
+  void set_allocated_fileencsha256(std::string* fileencsha256);
+  private:
+  const std::string& _internal_fileencsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
+  std::string* _internal_mutable_fileencsha256();
+  public:
+
+  // optional bytes mediaKey = 3;
+  bool has_mediakey() const;
+  private:
+  bool _internal_has_mediakey() const;
+  public:
+  void clear_mediakey();
+  const std::string& mediakey() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediakey(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediakey();
+  PROTOBUF_NODISCARD std::string* release_mediakey();
+  void set_allocated_mediakey(std::string* mediakey);
+  private:
+  const std::string& _internal_mediakey() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
+  std::string* _internal_mutable_mediakey();
+  public:
+
+  // optional string mimetype = 4;
+  bool has_mimetype() const;
+  private:
+  bool _internal_has_mimetype() const;
+  public:
+  void clear_mimetype();
+  const std::string& mimetype() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mimetype(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mimetype();
+  PROTOBUF_NODISCARD std::string* release_mimetype();
+  void set_allocated_mimetype(std::string* mimetype);
+  private:
+  const std::string& _internal_mimetype() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
+  std::string* _internal_mutable_mimetype();
+  public:
+
+  // optional string directPath = 7;
+  bool has_directpath() const;
+  private:
+  bool _internal_has_directpath() const;
+  public:
+  void clear_directpath();
+  const std::string& directpath() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directpath(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directpath();
+  PROTOBUF_NODISCARD std::string* release_directpath();
+  void set_allocated_directpath(std::string* directpath);
+  private:
+  const std::string& _internal_directpath() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
+  std::string* _internal_mutable_directpath();
+  public:
+
+  // optional uint32 height = 5;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  uint32_t height() const;
+  void set_height(uint32_t value);
+  private:
+  uint32_t _internal_height() const;
+  void _internal_set_height(uint32_t value);
+  public:
+
+  // optional uint32 width = 6;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  uint32_t width() const;
+  void set_width(uint32_t value);
+  private:
+  uint32_t _internal_width() const;
+  void _internal_set_width(uint32_t value);
+  public:
+
+  // optional uint64 fileLength = 8;
+  bool has_filelength() const;
+  private:
+  bool _internal_has_filelength() const;
+  public:
+  void clear_filelength();
+  uint64_t filelength() const;
+  void set_filelength(uint64_t value);
+  private:
+  uint64_t _internal_filelength() const;
+  void _internal_set_filelength(uint64_t value);
+  public:
+
+  // optional bool isFavorite = 9;
+  bool has_isfavorite() const;
+  private:
+  bool _internal_has_isfavorite() const;
+  public:
+  void clear_isfavorite();
+  bool isfavorite() const;
+  void set_isfavorite(bool value);
+  private:
+  bool _internal_isfavorite() const;
+  void _internal_set_isfavorite(bool value);
+  public:
+
+  // optional uint32 deviceIdHint = 10;
+  bool has_deviceidhint() const;
+  private:
+  bool _internal_has_deviceidhint() const;
+  public:
+  void clear_deviceidhint();
+  uint32_t deviceidhint() const;
+  void set_deviceidhint(uint32_t value);
+  private:
+  uint32_t _internal_deviceidhint() const;
+  void _internal_set_deviceidhint(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StickerAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
+    uint32_t height_;
+    uint32_t width_;
+    uint64_t filelength_;
+    bool isfavorite_;
+    uint32_t deviceidhint_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_SubscriptionAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SubscriptionAction) */ {
+ public:
+  inline SyncActionValue_SubscriptionAction() : SyncActionValue_SubscriptionAction(nullptr) {}
+  ~SyncActionValue_SubscriptionAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from);
+  SyncActionValue_SubscriptionAction(SyncActionValue_SubscriptionAction&& from) noexcept
+    : SyncActionValue_SubscriptionAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_SubscriptionAction& operator=(const SyncActionValue_SubscriptionAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_SubscriptionAction& operator=(SyncActionValue_SubscriptionAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_SubscriptionAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_SubscriptionAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_SubscriptionAction*>(
+               &_SyncActionValue_SubscriptionAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    198;
+
+  friend void swap(SyncActionValue_SubscriptionAction& a, SyncActionValue_SubscriptionAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_SubscriptionAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_SubscriptionAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_SubscriptionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_SubscriptionAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_SubscriptionAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_SubscriptionAction& from) {
+    SyncActionValue_SubscriptionAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_SubscriptionAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.SubscriptionAction";
+  }
+  protected:
+  explicit SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpirationDateFieldNumber = 3,
+    kIsDeactivatedFieldNumber = 1,
+    kIsAutoRenewingFieldNumber = 2,
+  };
+  // optional int64 expirationDate = 3;
+  bool has_expirationdate() const;
+  private:
+  bool _internal_has_expirationdate() const;
+  public:
+  void clear_expirationdate();
+  int64_t expirationdate() const;
+  void set_expirationdate(int64_t value);
+  private:
+  int64_t _internal_expirationdate() const;
+  void _internal_set_expirationdate(int64_t value);
+  public:
+
+  // optional bool isDeactivated = 1;
+  bool has_isdeactivated() const;
+  private:
+  bool _internal_has_isdeactivated() const;
+  public:
+  void clear_isdeactivated();
+  bool isdeactivated() const;
+  void set_isdeactivated(bool value);
+  private:
+  bool _internal_isdeactivated() const;
+  void _internal_set_isdeactivated(bool value);
+  public:
+
+  // optional bool isAutoRenewing = 2;
+  bool has_isautorenewing() const;
+  private:
+  bool _internal_has_isautorenewing() const;
+  public:
+  void clear_isautorenewing();
+  bool isautorenewing() const;
+  void set_isautorenewing(bool value);
+  private:
+  bool _internal_isautorenewing() const;
+  void _internal_set_isautorenewing(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SubscriptionAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int64_t expirationdate_;
+    bool isdeactivated_;
+    bool isautorenewing_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_SyncActionMessageRange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessageRange) */ {
+ public:
+  inline SyncActionValue_SyncActionMessageRange() : SyncActionValue_SyncActionMessageRange(nullptr) {}
+  ~SyncActionValue_SyncActionMessageRange() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from);
+  SyncActionValue_SyncActionMessageRange(SyncActionValue_SyncActionMessageRange&& from) noexcept
+    : SyncActionValue_SyncActionMessageRange() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_SyncActionMessageRange& operator=(const SyncActionValue_SyncActionMessageRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_SyncActionMessageRange& operator=(SyncActionValue_SyncActionMessageRange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_SyncActionMessageRange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_SyncActionMessageRange* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_SyncActionMessageRange*>(
+               &_SyncActionValue_SyncActionMessageRange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    199;
+
+  friend void swap(SyncActionValue_SyncActionMessageRange& a, SyncActionValue_SyncActionMessageRange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_SyncActionMessageRange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_SyncActionMessageRange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_SyncActionMessageRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_SyncActionMessageRange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_SyncActionMessageRange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_SyncActionMessageRange& from) {
+    SyncActionValue_SyncActionMessageRange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_SyncActionMessageRange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.SyncActionMessageRange";
+  }
+  protected:
+  explicit SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessagesFieldNumber = 3,
+    kLastMessageTimestampFieldNumber = 1,
+    kLastSystemMessageTimestampFieldNumber = 2,
+  };
+  // repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
+  int messages_size() const;
+  private:
+  int _internal_messages_size() const;
+  public:
+  void clear_messages();
+  ::proto::SyncActionValue_SyncActionMessage* mutable_messages(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >*
+      mutable_messages();
+  private:
+  const ::proto::SyncActionValue_SyncActionMessage& _internal_messages(int index) const;
+  ::proto::SyncActionValue_SyncActionMessage* _internal_add_messages();
+  public:
+  const ::proto::SyncActionValue_SyncActionMessage& messages(int index) const;
+  ::proto::SyncActionValue_SyncActionMessage* add_messages();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >&
+      messages() const;
+
+  // optional int64 lastMessageTimestamp = 1;
+  bool has_lastmessagetimestamp() const;
+  private:
+  bool _internal_has_lastmessagetimestamp() const;
+  public:
+  void clear_lastmessagetimestamp();
+  int64_t lastmessagetimestamp() const;
+  void set_lastmessagetimestamp(int64_t value);
+  private:
+  int64_t _internal_lastmessagetimestamp() const;
+  void _internal_set_lastmessagetimestamp(int64_t value);
+  public:
+
+  // optional int64 lastSystemMessageTimestamp = 2;
+  bool has_lastsystemmessagetimestamp() const;
+  private:
+  bool _internal_has_lastsystemmessagetimestamp() const;
+  public:
+  void clear_lastsystemmessagetimestamp();
+  int64_t lastsystemmessagetimestamp() const;
+  void set_lastsystemmessagetimestamp(int64_t value);
+  private:
+  int64_t _internal_lastsystemmessagetimestamp() const;
+  void _internal_set_lastsystemmessagetimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessageRange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage > messages_;
+    int64_t lastmessagetimestamp_;
+    int64_t lastsystemmessagetimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_SyncActionMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessage) */ {
+ public:
+  inline SyncActionValue_SyncActionMessage() : SyncActionValue_SyncActionMessage(nullptr) {}
+  ~SyncActionValue_SyncActionMessage() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from);
+  SyncActionValue_SyncActionMessage(SyncActionValue_SyncActionMessage&& from) noexcept
+    : SyncActionValue_SyncActionMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_SyncActionMessage& operator=(const SyncActionValue_SyncActionMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_SyncActionMessage& operator=(SyncActionValue_SyncActionMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_SyncActionMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_SyncActionMessage* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_SyncActionMessage*>(
+               &_SyncActionValue_SyncActionMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    200;
+
+  friend void swap(SyncActionValue_SyncActionMessage& a, SyncActionValue_SyncActionMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_SyncActionMessage* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_SyncActionMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_SyncActionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_SyncActionMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_SyncActionMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_SyncActionMessage& from) {
+    SyncActionValue_SyncActionMessage::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_SyncActionMessage* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.SyncActionMessage";
+  }
+  protected:
+  explicit SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+  };
+  // optional .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional int64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::MessageKey* key_;
+    int64_t timestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_TimeFormatAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.TimeFormatAction) */ {
+ public:
+  inline SyncActionValue_TimeFormatAction() : SyncActionValue_TimeFormatAction(nullptr) {}
+  ~SyncActionValue_TimeFormatAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from);
+  SyncActionValue_TimeFormatAction(SyncActionValue_TimeFormatAction&& from) noexcept
+    : SyncActionValue_TimeFormatAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_TimeFormatAction& operator=(const SyncActionValue_TimeFormatAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_TimeFormatAction& operator=(SyncActionValue_TimeFormatAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_TimeFormatAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_TimeFormatAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_TimeFormatAction*>(
+               &_SyncActionValue_TimeFormatAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    201;
+
+  friend void swap(SyncActionValue_TimeFormatAction& a, SyncActionValue_TimeFormatAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_TimeFormatAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_TimeFormatAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_TimeFormatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_TimeFormatAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_TimeFormatAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_TimeFormatAction& from) {
+    SyncActionValue_TimeFormatAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_TimeFormatAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.TimeFormatAction";
+  }
+  protected:
+  explicit SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIsTwentyFourHourFormatEnabledFieldNumber = 1,
+  };
+  // optional bool isTwentyFourHourFormatEnabled = 1;
+  bool has_istwentyfourhourformatenabled() const;
+  private:
+  bool _internal_has_istwentyfourhourformatenabled() const;
+  public:
+  void clear_istwentyfourhourformatenabled();
+  bool istwentyfourhourformatenabled() const;
+  void set_istwentyfourhourformatenabled(bool value);
+  private:
+  bool _internal_istwentyfourhourformatenabled() const;
+  void _internal_set_istwentyfourhourformatenabled(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.TimeFormatAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool istwentyfourhourformatenabled_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_UnarchiveChatsSetting final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UnarchiveChatsSetting) */ {
+ public:
+  inline SyncActionValue_UnarchiveChatsSetting() : SyncActionValue_UnarchiveChatsSetting(nullptr) {}
+  ~SyncActionValue_UnarchiveChatsSetting() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from);
+  SyncActionValue_UnarchiveChatsSetting(SyncActionValue_UnarchiveChatsSetting&& from) noexcept
+    : SyncActionValue_UnarchiveChatsSetting() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_UnarchiveChatsSetting& operator=(const SyncActionValue_UnarchiveChatsSetting& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_UnarchiveChatsSetting& operator=(SyncActionValue_UnarchiveChatsSetting&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_UnarchiveChatsSetting& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_UnarchiveChatsSetting* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_UnarchiveChatsSetting*>(
+               &_SyncActionValue_UnarchiveChatsSetting_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    202;
+
+  friend void swap(SyncActionValue_UnarchiveChatsSetting& a, SyncActionValue_UnarchiveChatsSetting& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_UnarchiveChatsSetting* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_UnarchiveChatsSetting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_UnarchiveChatsSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_UnarchiveChatsSetting>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_UnarchiveChatsSetting& from) {
+    SyncActionValue_UnarchiveChatsSetting::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_UnarchiveChatsSetting* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.UnarchiveChatsSetting";
+  }
+  protected:
+  explicit SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUnarchiveChatsFieldNumber = 1,
+  };
+  // optional bool unarchiveChats = 1;
+  bool has_unarchivechats() const;
+  private:
+  bool _internal_has_unarchivechats() const;
+  public:
+  void clear_unarchivechats();
+  bool unarchivechats() const;
+  void set_unarchivechats(bool value);
+  private:
+  bool _internal_unarchivechats() const;
+  void _internal_set_unarchivechats(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UnarchiveChatsSetting)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool unarchivechats_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue_UserStatusMuteAction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UserStatusMuteAction) */ {
+ public:
+  inline SyncActionValue_UserStatusMuteAction() : SyncActionValue_UserStatusMuteAction(nullptr) {}
+  ~SyncActionValue_UserStatusMuteAction() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from);
+  SyncActionValue_UserStatusMuteAction(SyncActionValue_UserStatusMuteAction&& from) noexcept
+    : SyncActionValue_UserStatusMuteAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue_UserStatusMuteAction& operator=(const SyncActionValue_UserStatusMuteAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue_UserStatusMuteAction& operator=(SyncActionValue_UserStatusMuteAction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue_UserStatusMuteAction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue_UserStatusMuteAction* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue_UserStatusMuteAction*>(
+               &_SyncActionValue_UserStatusMuteAction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    203;
+
+  friend void swap(SyncActionValue_UserStatusMuteAction& a, SyncActionValue_UserStatusMuteAction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue_UserStatusMuteAction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue_UserStatusMuteAction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue_UserStatusMuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue_UserStatusMuteAction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue_UserStatusMuteAction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue_UserStatusMuteAction& from) {
+    SyncActionValue_UserStatusMuteAction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue_UserStatusMuteAction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue.UserStatusMuteAction";
+  }
+  protected:
+  explicit SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMutedFieldNumber = 1,
+  };
+  // optional bool muted = 1;
+  bool has_muted() const;
+  private:
+  bool _internal_has_muted() const;
+  public:
+  void clear_muted();
+  bool muted() const;
+  void set_muted(bool value);
+  private:
+  bool _internal_muted() const;
+  void _internal_set_muted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UserStatusMuteAction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool muted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncActionValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue) */ {
+ public:
+  inline SyncActionValue() : SyncActionValue(nullptr) {}
+  ~SyncActionValue() override;
+  explicit PROTOBUF_CONSTEXPR SyncActionValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncActionValue(const SyncActionValue& from);
+  SyncActionValue(SyncActionValue&& from) noexcept
+    : SyncActionValue() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncActionValue& operator=(const SyncActionValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncActionValue& operator=(SyncActionValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncActionValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncActionValue* internal_default_instance() {
+    return reinterpret_cast<const SyncActionValue*>(
+               &_SyncActionValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    204;
+
+  friend void swap(SyncActionValue& a, SyncActionValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncActionValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncActionValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncActionValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncActionValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncActionValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncActionValue& from) {
+    SyncActionValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncActionValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncActionValue";
+  }
+  protected:
+  explicit SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SyncActionValue_AgentAction AgentAction;
+  typedef SyncActionValue_AndroidUnsupportedActions AndroidUnsupportedActions;
+  typedef SyncActionValue_ArchiveChatAction ArchiveChatAction;
+  typedef SyncActionValue_ClearChatAction ClearChatAction;
+  typedef SyncActionValue_ContactAction ContactAction;
+  typedef SyncActionValue_DeleteChatAction DeleteChatAction;
+  typedef SyncActionValue_DeleteMessageForMeAction DeleteMessageForMeAction;
+  typedef SyncActionValue_KeyExpiration KeyExpiration;
+  typedef SyncActionValue_LabelAssociationAction LabelAssociationAction;
+  typedef SyncActionValue_LabelEditAction LabelEditAction;
+  typedef SyncActionValue_LocaleSetting LocaleSetting;
+  typedef SyncActionValue_MarkChatAsReadAction MarkChatAsReadAction;
+  typedef SyncActionValue_MuteAction MuteAction;
+  typedef SyncActionValue_NuxAction NuxAction;
+  typedef SyncActionValue_PinAction PinAction;
+  typedef SyncActionValue_PrimaryFeature PrimaryFeature;
+  typedef SyncActionValue_PrimaryVersionAction PrimaryVersionAction;
+  typedef SyncActionValue_PushNameSetting PushNameSetting;
+  typedef SyncActionValue_QuickReplyAction QuickReplyAction;
+  typedef SyncActionValue_RecentEmojiWeightsAction RecentEmojiWeightsAction;
+  typedef SyncActionValue_SecurityNotificationSetting SecurityNotificationSetting;
+  typedef SyncActionValue_StarAction StarAction;
+  typedef SyncActionValue_StickerAction StickerAction;
+  typedef SyncActionValue_SubscriptionAction SubscriptionAction;
+  typedef SyncActionValue_SyncActionMessageRange SyncActionMessageRange;
+  typedef SyncActionValue_SyncActionMessage SyncActionMessage;
+  typedef SyncActionValue_TimeFormatAction TimeFormatAction;
+  typedef SyncActionValue_UnarchiveChatsSetting UnarchiveChatsSetting;
+  typedef SyncActionValue_UserStatusMuteAction UserStatusMuteAction;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStarActionFieldNumber = 2,
+    kContactActionFieldNumber = 3,
+    kMuteActionFieldNumber = 4,
+    kPinActionFieldNumber = 5,
+    kSecurityNotificationSettingFieldNumber = 6,
+    kPushNameSettingFieldNumber = 7,
+    kQuickReplyActionFieldNumber = 8,
+    kRecentEmojiWeightsActionFieldNumber = 11,
+    kLabelEditActionFieldNumber = 14,
+    kLabelAssociationActionFieldNumber = 15,
+    kLocaleSettingFieldNumber = 16,
+    kArchiveChatActionFieldNumber = 17,
+    kDeleteMessageForMeActionFieldNumber = 18,
+    kKeyExpirationFieldNumber = 19,
+    kMarkChatAsReadActionFieldNumber = 20,
+    kClearChatActionFieldNumber = 21,
+    kDeleteChatActionFieldNumber = 22,
+    kUnarchiveChatsSettingFieldNumber = 23,
+    kPrimaryFeatureFieldNumber = 24,
+    kAndroidUnsupportedActionsFieldNumber = 26,
+    kAgentActionFieldNumber = 27,
+    kSubscriptionActionFieldNumber = 28,
+    kUserStatusMuteActionFieldNumber = 29,
+    kTimeFormatActionFieldNumber = 30,
+    kNuxActionFieldNumber = 31,
+    kPrimaryVersionActionFieldNumber = 32,
+    kStickerActionFieldNumber = 33,
+    kTimestampFieldNumber = 1,
+  };
+  // optional .proto.SyncActionValue.StarAction starAction = 2;
+  bool has_staraction() const;
+  private:
+  bool _internal_has_staraction() const;
+  public:
+  void clear_staraction();
+  const ::proto::SyncActionValue_StarAction& staraction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_StarAction* release_staraction();
+  ::proto::SyncActionValue_StarAction* mutable_staraction();
+  void set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction);
+  private:
+  const ::proto::SyncActionValue_StarAction& _internal_staraction() const;
+  ::proto::SyncActionValue_StarAction* _internal_mutable_staraction();
+  public:
+  void unsafe_arena_set_allocated_staraction(
+      ::proto::SyncActionValue_StarAction* staraction);
+  ::proto::SyncActionValue_StarAction* unsafe_arena_release_staraction();
+
+  // optional .proto.SyncActionValue.ContactAction contactAction = 3;
+  bool has_contactaction() const;
+  private:
+  bool _internal_has_contactaction() const;
+  public:
+  void clear_contactaction();
+  const ::proto::SyncActionValue_ContactAction& contactaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_ContactAction* release_contactaction();
+  ::proto::SyncActionValue_ContactAction* mutable_contactaction();
+  void set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction);
+  private:
+  const ::proto::SyncActionValue_ContactAction& _internal_contactaction() const;
+  ::proto::SyncActionValue_ContactAction* _internal_mutable_contactaction();
+  public:
+  void unsafe_arena_set_allocated_contactaction(
+      ::proto::SyncActionValue_ContactAction* contactaction);
+  ::proto::SyncActionValue_ContactAction* unsafe_arena_release_contactaction();
+
+  // optional .proto.SyncActionValue.MuteAction muteAction = 4;
+  bool has_muteaction() const;
+  private:
+  bool _internal_has_muteaction() const;
+  public:
+  void clear_muteaction();
+  const ::proto::SyncActionValue_MuteAction& muteaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_MuteAction* release_muteaction();
+  ::proto::SyncActionValue_MuteAction* mutable_muteaction();
+  void set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction);
+  private:
+  const ::proto::SyncActionValue_MuteAction& _internal_muteaction() const;
+  ::proto::SyncActionValue_MuteAction* _internal_mutable_muteaction();
+  public:
+  void unsafe_arena_set_allocated_muteaction(
+      ::proto::SyncActionValue_MuteAction* muteaction);
+  ::proto::SyncActionValue_MuteAction* unsafe_arena_release_muteaction();
+
+  // optional .proto.SyncActionValue.PinAction pinAction = 5;
+  bool has_pinaction() const;
+  private:
+  bool _internal_has_pinaction() const;
+  public:
+  void clear_pinaction();
+  const ::proto::SyncActionValue_PinAction& pinaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_PinAction* release_pinaction();
+  ::proto::SyncActionValue_PinAction* mutable_pinaction();
+  void set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction);
+  private:
+  const ::proto::SyncActionValue_PinAction& _internal_pinaction() const;
+  ::proto::SyncActionValue_PinAction* _internal_mutable_pinaction();
+  public:
+  void unsafe_arena_set_allocated_pinaction(
+      ::proto::SyncActionValue_PinAction* pinaction);
+  ::proto::SyncActionValue_PinAction* unsafe_arena_release_pinaction();
+
+  // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
+  bool has_securitynotificationsetting() const;
+  private:
+  bool _internal_has_securitynotificationsetting() const;
+  public:
+  void clear_securitynotificationsetting();
+  const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SecurityNotificationSetting* release_securitynotificationsetting();
+  ::proto::SyncActionValue_SecurityNotificationSetting* mutable_securitynotificationsetting();
+  void set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting);
+  private:
+  const ::proto::SyncActionValue_SecurityNotificationSetting& _internal_securitynotificationsetting() const;
+  ::proto::SyncActionValue_SecurityNotificationSetting* _internal_mutable_securitynotificationsetting();
+  public:
+  void unsafe_arena_set_allocated_securitynotificationsetting(
+      ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting);
+  ::proto::SyncActionValue_SecurityNotificationSetting* unsafe_arena_release_securitynotificationsetting();
+
+  // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
+  bool has_pushnamesetting() const;
+  private:
+  bool _internal_has_pushnamesetting() const;
+  public:
+  void clear_pushnamesetting();
+  const ::proto::SyncActionValue_PushNameSetting& pushnamesetting() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_PushNameSetting* release_pushnamesetting();
+  ::proto::SyncActionValue_PushNameSetting* mutable_pushnamesetting();
+  void set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting);
+  private:
+  const ::proto::SyncActionValue_PushNameSetting& _internal_pushnamesetting() const;
+  ::proto::SyncActionValue_PushNameSetting* _internal_mutable_pushnamesetting();
+  public:
+  void unsafe_arena_set_allocated_pushnamesetting(
+      ::proto::SyncActionValue_PushNameSetting* pushnamesetting);
+  ::proto::SyncActionValue_PushNameSetting* unsafe_arena_release_pushnamesetting();
+
+  // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
+  bool has_quickreplyaction() const;
+  private:
+  bool _internal_has_quickreplyaction() const;
+  public:
+  void clear_quickreplyaction();
+  const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_QuickReplyAction* release_quickreplyaction();
+  ::proto::SyncActionValue_QuickReplyAction* mutable_quickreplyaction();
+  void set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction);
+  private:
+  const ::proto::SyncActionValue_QuickReplyAction& _internal_quickreplyaction() const;
+  ::proto::SyncActionValue_QuickReplyAction* _internal_mutable_quickreplyaction();
+  public:
+  void unsafe_arena_set_allocated_quickreplyaction(
+      ::proto::SyncActionValue_QuickReplyAction* quickreplyaction);
+  ::proto::SyncActionValue_QuickReplyAction* unsafe_arena_release_quickreplyaction();
+
+  // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+  bool has_recentemojiweightsaction() const;
+  private:
+  bool _internal_has_recentemojiweightsaction() const;
+  public:
+  void clear_recentemojiweightsaction();
+  const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_RecentEmojiWeightsAction* release_recentemojiweightsaction();
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* mutable_recentemojiweightsaction();
+  void set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction);
+  private:
+  const ::proto::SyncActionValue_RecentEmojiWeightsAction& _internal_recentemojiweightsaction() const;
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* _internal_mutable_recentemojiweightsaction();
+  public:
+  void unsafe_arena_set_allocated_recentemojiweightsaction(
+      ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction);
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* unsafe_arena_release_recentemojiweightsaction();
+
+  // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
+  bool has_labeleditaction() const;
+  private:
+  bool _internal_has_labeleditaction() const;
+  public:
+  void clear_labeleditaction();
+  const ::proto::SyncActionValue_LabelEditAction& labeleditaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelEditAction* release_labeleditaction();
+  ::proto::SyncActionValue_LabelEditAction* mutable_labeleditaction();
+  void set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction);
+  private:
+  const ::proto::SyncActionValue_LabelEditAction& _internal_labeleditaction() const;
+  ::proto::SyncActionValue_LabelEditAction* _internal_mutable_labeleditaction();
+  public:
+  void unsafe_arena_set_allocated_labeleditaction(
+      ::proto::SyncActionValue_LabelEditAction* labeleditaction);
+  ::proto::SyncActionValue_LabelEditAction* unsafe_arena_release_labeleditaction();
+
+  // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
+  bool has_labelassociationaction() const;
+  private:
+  bool _internal_has_labelassociationaction() const;
+  public:
+  void clear_labelassociationaction();
+  const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelAssociationAction* release_labelassociationaction();
+  ::proto::SyncActionValue_LabelAssociationAction* mutable_labelassociationaction();
+  void set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction);
+  private:
+  const ::proto::SyncActionValue_LabelAssociationAction& _internal_labelassociationaction() const;
+  ::proto::SyncActionValue_LabelAssociationAction* _internal_mutable_labelassociationaction();
+  public:
+  void unsafe_arena_set_allocated_labelassociationaction(
+      ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction);
+  ::proto::SyncActionValue_LabelAssociationAction* unsafe_arena_release_labelassociationaction();
+
+  // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
+  bool has_localesetting() const;
+  private:
+  bool _internal_has_localesetting() const;
+  public:
+  void clear_localesetting();
+  const ::proto::SyncActionValue_LocaleSetting& localesetting() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_LocaleSetting* release_localesetting();
+  ::proto::SyncActionValue_LocaleSetting* mutable_localesetting();
+  void set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting);
+  private:
+  const ::proto::SyncActionValue_LocaleSetting& _internal_localesetting() const;
+  ::proto::SyncActionValue_LocaleSetting* _internal_mutable_localesetting();
+  public:
+  void unsafe_arena_set_allocated_localesetting(
+      ::proto::SyncActionValue_LocaleSetting* localesetting);
+  ::proto::SyncActionValue_LocaleSetting* unsafe_arena_release_localesetting();
+
+  // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
+  bool has_archivechataction() const;
+  private:
+  bool _internal_has_archivechataction() const;
+  public:
+  void clear_archivechataction();
+  const ::proto::SyncActionValue_ArchiveChatAction& archivechataction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_ArchiveChatAction* release_archivechataction();
+  ::proto::SyncActionValue_ArchiveChatAction* mutable_archivechataction();
+  void set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction);
+  private:
+  const ::proto::SyncActionValue_ArchiveChatAction& _internal_archivechataction() const;
+  ::proto::SyncActionValue_ArchiveChatAction* _internal_mutable_archivechataction();
+  public:
+  void unsafe_arena_set_allocated_archivechataction(
+      ::proto::SyncActionValue_ArchiveChatAction* archivechataction);
+  ::proto::SyncActionValue_ArchiveChatAction* unsafe_arena_release_archivechataction();
+
+  // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
+  bool has_deletemessageformeaction() const;
+  private:
+  bool _internal_has_deletemessageformeaction() const;
+  public:
+  void clear_deletemessageformeaction();
+  const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteMessageForMeAction* release_deletemessageformeaction();
+  ::proto::SyncActionValue_DeleteMessageForMeAction* mutable_deletemessageformeaction();
+  void set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction);
+  private:
+  const ::proto::SyncActionValue_DeleteMessageForMeAction& _internal_deletemessageformeaction() const;
+  ::proto::SyncActionValue_DeleteMessageForMeAction* _internal_mutable_deletemessageformeaction();
+  public:
+  void unsafe_arena_set_allocated_deletemessageformeaction(
+      ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction);
+  ::proto::SyncActionValue_DeleteMessageForMeAction* unsafe_arena_release_deletemessageformeaction();
+
+  // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
+  bool has_keyexpiration() const;
+  private:
+  bool _internal_has_keyexpiration() const;
+  public:
+  void clear_keyexpiration();
+  const ::proto::SyncActionValue_KeyExpiration& keyexpiration() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_KeyExpiration* release_keyexpiration();
+  ::proto::SyncActionValue_KeyExpiration* mutable_keyexpiration();
+  void set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration);
+  private:
+  const ::proto::SyncActionValue_KeyExpiration& _internal_keyexpiration() const;
+  ::proto::SyncActionValue_KeyExpiration* _internal_mutable_keyexpiration();
+  public:
+  void unsafe_arena_set_allocated_keyexpiration(
+      ::proto::SyncActionValue_KeyExpiration* keyexpiration);
+  ::proto::SyncActionValue_KeyExpiration* unsafe_arena_release_keyexpiration();
+
+  // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
+  bool has_markchatasreadaction() const;
+  private:
+  bool _internal_has_markchatasreadaction() const;
+  public:
+  void clear_markchatasreadaction();
+  const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_MarkChatAsReadAction* release_markchatasreadaction();
+  ::proto::SyncActionValue_MarkChatAsReadAction* mutable_markchatasreadaction();
+  void set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction);
+  private:
+  const ::proto::SyncActionValue_MarkChatAsReadAction& _internal_markchatasreadaction() const;
+  ::proto::SyncActionValue_MarkChatAsReadAction* _internal_mutable_markchatasreadaction();
+  public:
+  void unsafe_arena_set_allocated_markchatasreadaction(
+      ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction);
+  ::proto::SyncActionValue_MarkChatAsReadAction* unsafe_arena_release_markchatasreadaction();
+
+  // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
+  bool has_clearchataction() const;
+  private:
+  bool _internal_has_clearchataction() const;
+  public:
+  void clear_clearchataction();
+  const ::proto::SyncActionValue_ClearChatAction& clearchataction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_ClearChatAction* release_clearchataction();
+  ::proto::SyncActionValue_ClearChatAction* mutable_clearchataction();
+  void set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction);
+  private:
+  const ::proto::SyncActionValue_ClearChatAction& _internal_clearchataction() const;
+  ::proto::SyncActionValue_ClearChatAction* _internal_mutable_clearchataction();
+  public:
+  void unsafe_arena_set_allocated_clearchataction(
+      ::proto::SyncActionValue_ClearChatAction* clearchataction);
+  ::proto::SyncActionValue_ClearChatAction* unsafe_arena_release_clearchataction();
+
+  // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
+  bool has_deletechataction() const;
+  private:
+  bool _internal_has_deletechataction() const;
+  public:
+  void clear_deletechataction();
+  const ::proto::SyncActionValue_DeleteChatAction& deletechataction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteChatAction* release_deletechataction();
+  ::proto::SyncActionValue_DeleteChatAction* mutable_deletechataction();
+  void set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction);
+  private:
+  const ::proto::SyncActionValue_DeleteChatAction& _internal_deletechataction() const;
+  ::proto::SyncActionValue_DeleteChatAction* _internal_mutable_deletechataction();
+  public:
+  void unsafe_arena_set_allocated_deletechataction(
+      ::proto::SyncActionValue_DeleteChatAction* deletechataction);
+  ::proto::SyncActionValue_DeleteChatAction* unsafe_arena_release_deletechataction();
+
+  // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
+  bool has_unarchivechatssetting() const;
+  private:
+  bool _internal_has_unarchivechatssetting() const;
+  public:
+  void clear_unarchivechatssetting();
+  const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_UnarchiveChatsSetting* release_unarchivechatssetting();
+  ::proto::SyncActionValue_UnarchiveChatsSetting* mutable_unarchivechatssetting();
+  void set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting);
+  private:
+  const ::proto::SyncActionValue_UnarchiveChatsSetting& _internal_unarchivechatssetting() const;
+  ::proto::SyncActionValue_UnarchiveChatsSetting* _internal_mutable_unarchivechatssetting();
+  public:
+  void unsafe_arena_set_allocated_unarchivechatssetting(
+      ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting);
+  ::proto::SyncActionValue_UnarchiveChatsSetting* unsafe_arena_release_unarchivechatssetting();
+
+  // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
+  bool has_primaryfeature() const;
+  private:
+  bool _internal_has_primaryfeature() const;
+  public:
+  void clear_primaryfeature();
+  const ::proto::SyncActionValue_PrimaryFeature& primaryfeature() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryFeature* release_primaryfeature();
+  ::proto::SyncActionValue_PrimaryFeature* mutable_primaryfeature();
+  void set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature);
+  private:
+  const ::proto::SyncActionValue_PrimaryFeature& _internal_primaryfeature() const;
+  ::proto::SyncActionValue_PrimaryFeature* _internal_mutable_primaryfeature();
+  public:
+  void unsafe_arena_set_allocated_primaryfeature(
+      ::proto::SyncActionValue_PrimaryFeature* primaryfeature);
+  ::proto::SyncActionValue_PrimaryFeature* unsafe_arena_release_primaryfeature();
+
+  // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
+  bool has_androidunsupportedactions() const;
+  private:
+  bool _internal_has_androidunsupportedactions() const;
+  public:
+  void clear_androidunsupportedactions();
+  const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_AndroidUnsupportedActions* release_androidunsupportedactions();
+  ::proto::SyncActionValue_AndroidUnsupportedActions* mutable_androidunsupportedactions();
+  void set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions);
+  private:
+  const ::proto::SyncActionValue_AndroidUnsupportedActions& _internal_androidunsupportedactions() const;
+  ::proto::SyncActionValue_AndroidUnsupportedActions* _internal_mutable_androidunsupportedactions();
+  public:
+  void unsafe_arena_set_allocated_androidunsupportedactions(
+      ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions);
+  ::proto::SyncActionValue_AndroidUnsupportedActions* unsafe_arena_release_androidunsupportedactions();
+
+  // optional .proto.SyncActionValue.AgentAction agentAction = 27;
+  bool has_agentaction() const;
+  private:
+  bool _internal_has_agentaction() const;
+  public:
+  void clear_agentaction();
+  const ::proto::SyncActionValue_AgentAction& agentaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_AgentAction* release_agentaction();
+  ::proto::SyncActionValue_AgentAction* mutable_agentaction();
+  void set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction);
+  private:
+  const ::proto::SyncActionValue_AgentAction& _internal_agentaction() const;
+  ::proto::SyncActionValue_AgentAction* _internal_mutable_agentaction();
+  public:
+  void unsafe_arena_set_allocated_agentaction(
+      ::proto::SyncActionValue_AgentAction* agentaction);
+  ::proto::SyncActionValue_AgentAction* unsafe_arena_release_agentaction();
+
+  // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
+  bool has_subscriptionaction() const;
+  private:
+  bool _internal_has_subscriptionaction() const;
+  public:
+  void clear_subscriptionaction();
+  const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_SubscriptionAction* release_subscriptionaction();
+  ::proto::SyncActionValue_SubscriptionAction* mutable_subscriptionaction();
+  void set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction);
+  private:
+  const ::proto::SyncActionValue_SubscriptionAction& _internal_subscriptionaction() const;
+  ::proto::SyncActionValue_SubscriptionAction* _internal_mutable_subscriptionaction();
+  public:
+  void unsafe_arena_set_allocated_subscriptionaction(
+      ::proto::SyncActionValue_SubscriptionAction* subscriptionaction);
+  ::proto::SyncActionValue_SubscriptionAction* unsafe_arena_release_subscriptionaction();
+
+  // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
+  bool has_userstatusmuteaction() const;
+  private:
+  bool _internal_has_userstatusmuteaction() const;
+  public:
+  void clear_userstatusmuteaction();
+  const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_UserStatusMuteAction* release_userstatusmuteaction();
+  ::proto::SyncActionValue_UserStatusMuteAction* mutable_userstatusmuteaction();
+  void set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction);
+  private:
+  const ::proto::SyncActionValue_UserStatusMuteAction& _internal_userstatusmuteaction() const;
+  ::proto::SyncActionValue_UserStatusMuteAction* _internal_mutable_userstatusmuteaction();
+  public:
+  void unsafe_arena_set_allocated_userstatusmuteaction(
+      ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction);
+  ::proto::SyncActionValue_UserStatusMuteAction* unsafe_arena_release_userstatusmuteaction();
+
+  // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
+  bool has_timeformataction() const;
+  private:
+  bool _internal_has_timeformataction() const;
+  public:
+  void clear_timeformataction();
+  const ::proto::SyncActionValue_TimeFormatAction& timeformataction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_TimeFormatAction* release_timeformataction();
+  ::proto::SyncActionValue_TimeFormatAction* mutable_timeformataction();
+  void set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction);
+  private:
+  const ::proto::SyncActionValue_TimeFormatAction& _internal_timeformataction() const;
+  ::proto::SyncActionValue_TimeFormatAction* _internal_mutable_timeformataction();
+  public:
+  void unsafe_arena_set_allocated_timeformataction(
+      ::proto::SyncActionValue_TimeFormatAction* timeformataction);
+  ::proto::SyncActionValue_TimeFormatAction* unsafe_arena_release_timeformataction();
+
+  // optional .proto.SyncActionValue.NuxAction nuxAction = 31;
+  bool has_nuxaction() const;
+  private:
+  bool _internal_has_nuxaction() const;
+  public:
+  void clear_nuxaction();
+  const ::proto::SyncActionValue_NuxAction& nuxaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_NuxAction* release_nuxaction();
+  ::proto::SyncActionValue_NuxAction* mutable_nuxaction();
+  void set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction);
+  private:
+  const ::proto::SyncActionValue_NuxAction& _internal_nuxaction() const;
+  ::proto::SyncActionValue_NuxAction* _internal_mutable_nuxaction();
+  public:
+  void unsafe_arena_set_allocated_nuxaction(
+      ::proto::SyncActionValue_NuxAction* nuxaction);
+  ::proto::SyncActionValue_NuxAction* unsafe_arena_release_nuxaction();
+
+  // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
+  bool has_primaryversionaction() const;
+  private:
+  bool _internal_has_primaryversionaction() const;
+  public:
+  void clear_primaryversionaction();
+  const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryVersionAction* release_primaryversionaction();
+  ::proto::SyncActionValue_PrimaryVersionAction* mutable_primaryversionaction();
+  void set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction);
+  private:
+  const ::proto::SyncActionValue_PrimaryVersionAction& _internal_primaryversionaction() const;
+  ::proto::SyncActionValue_PrimaryVersionAction* _internal_mutable_primaryversionaction();
+  public:
+  void unsafe_arena_set_allocated_primaryversionaction(
+      ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction);
+  ::proto::SyncActionValue_PrimaryVersionAction* unsafe_arena_release_primaryversionaction();
+
+  // optional .proto.SyncActionValue.StickerAction stickerAction = 33;
+  bool has_stickeraction() const;
+  private:
+  bool _internal_has_stickeraction() const;
+  public:
+  void clear_stickeraction();
+  const ::proto::SyncActionValue_StickerAction& stickeraction() const;
+  PROTOBUF_NODISCARD ::proto::SyncActionValue_StickerAction* release_stickeraction();
+  ::proto::SyncActionValue_StickerAction* mutable_stickeraction();
+  void set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction);
+  private:
+  const ::proto::SyncActionValue_StickerAction& _internal_stickeraction() const;
+  ::proto::SyncActionValue_StickerAction* _internal_mutable_stickeraction();
+  public:
+  void unsafe_arena_set_allocated_stickeraction(
+      ::proto::SyncActionValue_StickerAction* stickeraction);
+  ::proto::SyncActionValue_StickerAction* unsafe_arena_release_stickeraction();
+
+  // optional int64 timestamp = 1;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncActionValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncActionValue_StarAction* staraction_;
+    ::proto::SyncActionValue_ContactAction* contactaction_;
+    ::proto::SyncActionValue_MuteAction* muteaction_;
+    ::proto::SyncActionValue_PinAction* pinaction_;
+    ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting_;
+    ::proto::SyncActionValue_PushNameSetting* pushnamesetting_;
+    ::proto::SyncActionValue_QuickReplyAction* quickreplyaction_;
+    ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction_;
+    ::proto::SyncActionValue_LabelEditAction* labeleditaction_;
+    ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction_;
+    ::proto::SyncActionValue_LocaleSetting* localesetting_;
+    ::proto::SyncActionValue_ArchiveChatAction* archivechataction_;
+    ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction_;
+    ::proto::SyncActionValue_KeyExpiration* keyexpiration_;
+    ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction_;
+    ::proto::SyncActionValue_ClearChatAction* clearchataction_;
+    ::proto::SyncActionValue_DeleteChatAction* deletechataction_;
+    ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting_;
+    ::proto::SyncActionValue_PrimaryFeature* primaryfeature_;
+    ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions_;
+    ::proto::SyncActionValue_AgentAction* agentaction_;
+    ::proto::SyncActionValue_SubscriptionAction* subscriptionaction_;
+    ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction_;
+    ::proto::SyncActionValue_TimeFormatAction* timeformataction_;
+    ::proto::SyncActionValue_NuxAction* nuxaction_;
+    ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction_;
+    ::proto::SyncActionValue_StickerAction* stickeraction_;
+    int64_t timestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdIndex final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdIndex) */ {
+ public:
+  inline SyncdIndex() : SyncdIndex(nullptr) {}
+  ~SyncdIndex() override;
+  explicit PROTOBUF_CONSTEXPR SyncdIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdIndex(const SyncdIndex& from);
+  SyncdIndex(SyncdIndex&& from) noexcept
+    : SyncdIndex() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdIndex& operator=(const SyncdIndex& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdIndex& operator=(SyncdIndex&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdIndex& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdIndex* internal_default_instance() {
+    return reinterpret_cast<const SyncdIndex*>(
+               &_SyncdIndex_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    205;
+
+  friend void swap(SyncdIndex& a, SyncdIndex& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdIndex* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdIndex* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdIndex>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdIndex& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdIndex& from) {
+    SyncdIndex::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdIndex* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdIndex";
+  }
+  protected:
+  explicit SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBlobFieldNumber = 1,
+  };
+  // optional bytes blob = 1;
+  bool has_blob() const;
+  private:
+  bool _internal_has_blob() const;
+  public:
+  void clear_blob();
+  const std::string& blob() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_blob(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_blob();
+  PROTOBUF_NODISCARD std::string* release_blob();
+  void set_allocated_blob(std::string* blob);
+  private:
+  const std::string& _internal_blob() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value);
+  std::string* _internal_mutable_blob();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdIndex)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdMutation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutation) */ {
+ public:
+  inline SyncdMutation() : SyncdMutation(nullptr) {}
+  ~SyncdMutation() override;
+  explicit PROTOBUF_CONSTEXPR SyncdMutation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdMutation(const SyncdMutation& from);
+  SyncdMutation(SyncdMutation&& from) noexcept
+    : SyncdMutation() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdMutation& operator=(const SyncdMutation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdMutation& operator=(SyncdMutation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdMutation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdMutation* internal_default_instance() {
+    return reinterpret_cast<const SyncdMutation*>(
+               &_SyncdMutation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    206;
+
+  friend void swap(SyncdMutation& a, SyncdMutation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdMutation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdMutation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdMutation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdMutation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdMutation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdMutation& from) {
+    SyncdMutation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdMutation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdMutation";
+  }
+  protected:
+  explicit SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SyncdMutation_SyncdOperation SyncdOperation;
+  static constexpr SyncdOperation SET =
+    SyncdMutation_SyncdOperation_SET;
+  static constexpr SyncdOperation REMOVE =
+    SyncdMutation_SyncdOperation_REMOVE;
+  static inline bool SyncdOperation_IsValid(int value) {
+    return SyncdMutation_SyncdOperation_IsValid(value);
+  }
+  static constexpr SyncdOperation SyncdOperation_MIN =
+    SyncdMutation_SyncdOperation_SyncdOperation_MIN;
+  static constexpr SyncdOperation SyncdOperation_MAX =
+    SyncdMutation_SyncdOperation_SyncdOperation_MAX;
+  static constexpr int SyncdOperation_ARRAYSIZE =
+    SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SyncdOperation_descriptor() {
+    return SyncdMutation_SyncdOperation_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SyncdOperation_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SyncdOperation>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SyncdOperation_Name.");
+    return SyncdMutation_SyncdOperation_Name(enum_t_value);
+  }
+  static inline bool SyncdOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SyncdOperation* value) {
+    return SyncdMutation_SyncdOperation_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRecordFieldNumber = 2,
+    kOperationFieldNumber = 1,
+  };
+  // optional .proto.SyncdRecord record = 2;
+  bool has_record() const;
+  private:
+  bool _internal_has_record() const;
+  public:
+  void clear_record();
+  const ::proto::SyncdRecord& record() const;
+  PROTOBUF_NODISCARD ::proto::SyncdRecord* release_record();
+  ::proto::SyncdRecord* mutable_record();
+  void set_allocated_record(::proto::SyncdRecord* record);
+  private:
+  const ::proto::SyncdRecord& _internal_record() const;
+  ::proto::SyncdRecord* _internal_mutable_record();
+  public:
+  void unsafe_arena_set_allocated_record(
+      ::proto::SyncdRecord* record);
+  ::proto::SyncdRecord* unsafe_arena_release_record();
+
+  // optional .proto.SyncdMutation.SyncdOperation operation = 1;
+  bool has_operation() const;
+  private:
+  bool _internal_has_operation() const;
+  public:
+  void clear_operation();
+  ::proto::SyncdMutation_SyncdOperation operation() const;
+  void set_operation(::proto::SyncdMutation_SyncdOperation value);
+  private:
+  ::proto::SyncdMutation_SyncdOperation _internal_operation() const;
+  void _internal_set_operation(::proto::SyncdMutation_SyncdOperation value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdMutation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncdRecord* record_;
+    int operation_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdMutations final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutations) */ {
+ public:
+  inline SyncdMutations() : SyncdMutations(nullptr) {}
+  ~SyncdMutations() override;
+  explicit PROTOBUF_CONSTEXPR SyncdMutations(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdMutations(const SyncdMutations& from);
+  SyncdMutations(SyncdMutations&& from) noexcept
+    : SyncdMutations() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdMutations& operator=(const SyncdMutations& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdMutations& operator=(SyncdMutations&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdMutations& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdMutations* internal_default_instance() {
+    return reinterpret_cast<const SyncdMutations*>(
+               &_SyncdMutations_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    207;
+
+  friend void swap(SyncdMutations& a, SyncdMutations& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdMutations* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdMutations* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdMutations* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdMutations>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdMutations& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdMutations& from) {
+    SyncdMutations::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdMutations* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdMutations";
+  }
+  protected:
+  explicit SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMutationsFieldNumber = 1,
+  };
+  // repeated .proto.SyncdMutation mutations = 1;
+  int mutations_size() const;
+  private:
+  int _internal_mutations_size() const;
+  public:
+  void clear_mutations();
+  ::proto::SyncdMutation* mutable_mutations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
+      mutable_mutations();
+  private:
+  const ::proto::SyncdMutation& _internal_mutations(int index) const;
+  ::proto::SyncdMutation* _internal_add_mutations();
+  public:
+  const ::proto::SyncdMutation& mutations(int index) const;
+  ::proto::SyncdMutation* add_mutations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
+      mutations() const;
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdMutations)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdPatch final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdPatch) */ {
+ public:
+  inline SyncdPatch() : SyncdPatch(nullptr) {}
+  ~SyncdPatch() override;
+  explicit PROTOBUF_CONSTEXPR SyncdPatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdPatch(const SyncdPatch& from);
+  SyncdPatch(SyncdPatch&& from) noexcept
+    : SyncdPatch() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdPatch& operator=(const SyncdPatch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdPatch& operator=(SyncdPatch&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdPatch& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdPatch* internal_default_instance() {
+    return reinterpret_cast<const SyncdPatch*>(
+               &_SyncdPatch_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    208;
+
+  friend void swap(SyncdPatch& a, SyncdPatch& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdPatch* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdPatch* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdPatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdPatch>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdPatch& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdPatch& from) {
+    SyncdPatch::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdPatch* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdPatch";
+  }
+  protected:
+  explicit SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMutationsFieldNumber = 2,
+    kSnapshotMacFieldNumber = 4,
+    kPatchMacFieldNumber = 5,
+    kVersionFieldNumber = 1,
+    kExternalMutationsFieldNumber = 3,
+    kKeyIdFieldNumber = 6,
+    kExitCodeFieldNumber = 7,
+    kDeviceIndexFieldNumber = 8,
+  };
+  // repeated .proto.SyncdMutation mutations = 2;
+  int mutations_size() const;
+  private:
+  int _internal_mutations_size() const;
+  public:
+  void clear_mutations();
+  ::proto::SyncdMutation* mutable_mutations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
+      mutable_mutations();
+  private:
+  const ::proto::SyncdMutation& _internal_mutations(int index) const;
+  ::proto::SyncdMutation* _internal_add_mutations();
+  public:
+  const ::proto::SyncdMutation& mutations(int index) const;
+  ::proto::SyncdMutation* add_mutations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
+      mutations() const;
+
+  // optional bytes snapshotMac = 4;
+  bool has_snapshotmac() const;
+  private:
+  bool _internal_has_snapshotmac() const;
+  public:
+  void clear_snapshotmac();
+  const std::string& snapshotmac() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_snapshotmac(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_snapshotmac();
+  PROTOBUF_NODISCARD std::string* release_snapshotmac();
+  void set_allocated_snapshotmac(std::string* snapshotmac);
+  private:
+  const std::string& _internal_snapshotmac() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshotmac(const std::string& value);
+  std::string* _internal_mutable_snapshotmac();
+  public:
+
+  // optional bytes patchMac = 5;
+  bool has_patchmac() const;
+  private:
+  bool _internal_has_patchmac() const;
+  public:
+  void clear_patchmac();
+  const std::string& patchmac() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_patchmac(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_patchmac();
+  PROTOBUF_NODISCARD std::string* release_patchmac();
+  void set_allocated_patchmac(std::string* patchmac);
+  private:
+  const std::string& _internal_patchmac() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_patchmac(const std::string& value);
+  std::string* _internal_mutable_patchmac();
+  public:
+
+  // optional .proto.SyncdVersion version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const ::proto::SyncdVersion& version() const;
+  PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version();
+  ::proto::SyncdVersion* mutable_version();
+  void set_allocated_version(::proto::SyncdVersion* version);
+  private:
+  const ::proto::SyncdVersion& _internal_version() const;
+  ::proto::SyncdVersion* _internal_mutable_version();
+  public:
+  void unsafe_arena_set_allocated_version(
+      ::proto::SyncdVersion* version);
+  ::proto::SyncdVersion* unsafe_arena_release_version();
+
+  // optional .proto.ExternalBlobReference externalMutations = 3;
+  bool has_externalmutations() const;
+  private:
+  bool _internal_has_externalmutations() const;
+  public:
+  void clear_externalmutations();
+  const ::proto::ExternalBlobReference& externalmutations() const;
+  PROTOBUF_NODISCARD ::proto::ExternalBlobReference* release_externalmutations();
+  ::proto::ExternalBlobReference* mutable_externalmutations();
+  void set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations);
+  private:
+  const ::proto::ExternalBlobReference& _internal_externalmutations() const;
+  ::proto::ExternalBlobReference* _internal_mutable_externalmutations();
+  public:
+  void unsafe_arena_set_allocated_externalmutations(
+      ::proto::ExternalBlobReference* externalmutations);
+  ::proto::ExternalBlobReference* unsafe_arena_release_externalmutations();
+
+  // optional .proto.KeyId keyId = 6;
+  bool has_keyid() const;
+  private:
+  bool _internal_has_keyid() const;
+  public:
+  void clear_keyid();
+  const ::proto::KeyId& keyid() const;
+  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
+  ::proto::KeyId* mutable_keyid();
+  void set_allocated_keyid(::proto::KeyId* keyid);
+  private:
+  const ::proto::KeyId& _internal_keyid() const;
+  ::proto::KeyId* _internal_mutable_keyid();
+  public:
+  void unsafe_arena_set_allocated_keyid(
+      ::proto::KeyId* keyid);
+  ::proto::KeyId* unsafe_arena_release_keyid();
+
+  // optional .proto.ExitCode exitCode = 7;
+  bool has_exitcode() const;
+  private:
+  bool _internal_has_exitcode() const;
+  public:
+  void clear_exitcode();
+  const ::proto::ExitCode& exitcode() const;
+  PROTOBUF_NODISCARD ::proto::ExitCode* release_exitcode();
+  ::proto::ExitCode* mutable_exitcode();
+  void set_allocated_exitcode(::proto::ExitCode* exitcode);
+  private:
+  const ::proto::ExitCode& _internal_exitcode() const;
+  ::proto::ExitCode* _internal_mutable_exitcode();
+  public:
+  void unsafe_arena_set_allocated_exitcode(
+      ::proto::ExitCode* exitcode);
+  ::proto::ExitCode* unsafe_arena_release_exitcode();
+
+  // optional uint32 deviceIndex = 8;
+  bool has_deviceindex() const;
+  private:
+  bool _internal_has_deviceindex() const;
+  public:
+  void clear_deviceindex();
+  uint32_t deviceindex() const;
+  void set_deviceindex(uint32_t value);
+  private:
+  uint32_t _internal_deviceindex() const;
+  void _internal_set_deviceindex(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdPatch)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshotmac_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr patchmac_;
+    ::proto::SyncdVersion* version_;
+    ::proto::ExternalBlobReference* externalmutations_;
+    ::proto::KeyId* keyid_;
+    ::proto::ExitCode* exitcode_;
+    uint32_t deviceindex_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdRecord final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdRecord) */ {
+ public:
+  inline SyncdRecord() : SyncdRecord(nullptr) {}
+  ~SyncdRecord() override;
+  explicit PROTOBUF_CONSTEXPR SyncdRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdRecord(const SyncdRecord& from);
+  SyncdRecord(SyncdRecord&& from) noexcept
+    : SyncdRecord() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdRecord& operator=(const SyncdRecord& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdRecord& operator=(SyncdRecord&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdRecord& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdRecord* internal_default_instance() {
+    return reinterpret_cast<const SyncdRecord*>(
+               &_SyncdRecord_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    209;
+
+  friend void swap(SyncdRecord& a, SyncdRecord& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdRecord* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdRecord* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdRecord>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdRecord& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdRecord& from) {
+    SyncdRecord::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdRecord* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdRecord";
+  }
+  protected:
+  explicit SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndexFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kKeyIdFieldNumber = 3,
+  };
+  // optional .proto.SyncdIndex index = 1;
+  bool has_index() const;
+  private:
+  bool _internal_has_index() const;
+  public:
+  void clear_index();
+  const ::proto::SyncdIndex& index() const;
+  PROTOBUF_NODISCARD ::proto::SyncdIndex* release_index();
+  ::proto::SyncdIndex* mutable_index();
+  void set_allocated_index(::proto::SyncdIndex* index);
+  private:
+  const ::proto::SyncdIndex& _internal_index() const;
+  ::proto::SyncdIndex* _internal_mutable_index();
+  public:
+  void unsafe_arena_set_allocated_index(
+      ::proto::SyncdIndex* index);
+  ::proto::SyncdIndex* unsafe_arena_release_index();
+
+  // optional .proto.SyncdValue value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::proto::SyncdValue& value() const;
+  PROTOBUF_NODISCARD ::proto::SyncdValue* release_value();
+  ::proto::SyncdValue* mutable_value();
+  void set_allocated_value(::proto::SyncdValue* value);
+  private:
+  const ::proto::SyncdValue& _internal_value() const;
+  ::proto::SyncdValue* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::proto::SyncdValue* value);
+  ::proto::SyncdValue* unsafe_arena_release_value();
+
+  // optional .proto.KeyId keyId = 3;
+  bool has_keyid() const;
+  private:
+  bool _internal_has_keyid() const;
+  public:
+  void clear_keyid();
+  const ::proto::KeyId& keyid() const;
+  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
+  ::proto::KeyId* mutable_keyid();
+  void set_allocated_keyid(::proto::KeyId* keyid);
+  private:
+  const ::proto::KeyId& _internal_keyid() const;
+  ::proto::KeyId* _internal_mutable_keyid();
+  public:
+  void unsafe_arena_set_allocated_keyid(
+      ::proto::KeyId* keyid);
+  ::proto::KeyId* unsafe_arena_release_keyid();
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdRecord)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::SyncdIndex* index_;
+    ::proto::SyncdValue* value_;
+    ::proto::KeyId* keyid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdSnapshot final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdSnapshot) */ {
+ public:
+  inline SyncdSnapshot() : SyncdSnapshot(nullptr) {}
+  ~SyncdSnapshot() override;
+  explicit PROTOBUF_CONSTEXPR SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdSnapshot(const SyncdSnapshot& from);
+  SyncdSnapshot(SyncdSnapshot&& from) noexcept
+    : SyncdSnapshot() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdSnapshot& operator=(const SyncdSnapshot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdSnapshot& operator=(SyncdSnapshot&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdSnapshot& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdSnapshot* internal_default_instance() {
+    return reinterpret_cast<const SyncdSnapshot*>(
+               &_SyncdSnapshot_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    210;
+
+  friend void swap(SyncdSnapshot& a, SyncdSnapshot& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdSnapshot* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdSnapshot* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdSnapshot>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdSnapshot& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdSnapshot& from) {
+    SyncdSnapshot::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdSnapshot* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdSnapshot";
+  }
+  protected:
+  explicit SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRecordsFieldNumber = 2,
+    kMacFieldNumber = 3,
+    kVersionFieldNumber = 1,
+    kKeyIdFieldNumber = 4,
+  };
+  // repeated .proto.SyncdRecord records = 2;
+  int records_size() const;
+  private:
+  int _internal_records_size() const;
+  public:
+  void clear_records();
+  ::proto::SyncdRecord* mutable_records(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >*
+      mutable_records();
+  private:
+  const ::proto::SyncdRecord& _internal_records(int index) const;
+  ::proto::SyncdRecord* _internal_add_records();
+  public:
+  const ::proto::SyncdRecord& records(int index) const;
+  ::proto::SyncdRecord* add_records();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >&
+      records() const;
+
+  // optional bytes mac = 3;
+  bool has_mac() const;
+  private:
+  bool _internal_has_mac() const;
+  public:
+  void clear_mac();
+  const std::string& mac() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mac(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mac();
+  PROTOBUF_NODISCARD std::string* release_mac();
+  void set_allocated_mac(std::string* mac);
+  private:
+  const std::string& _internal_mac() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac(const std::string& value);
+  std::string* _internal_mutable_mac();
+  public:
+
+  // optional .proto.SyncdVersion version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const ::proto::SyncdVersion& version() const;
+  PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version();
+  ::proto::SyncdVersion* mutable_version();
+  void set_allocated_version(::proto::SyncdVersion* version);
+  private:
+  const ::proto::SyncdVersion& _internal_version() const;
+  ::proto::SyncdVersion* _internal_mutable_version();
+  public:
+  void unsafe_arena_set_allocated_version(
+      ::proto::SyncdVersion* version);
+  ::proto::SyncdVersion* unsafe_arena_release_version();
+
+  // optional .proto.KeyId keyId = 4;
+  bool has_keyid() const;
+  private:
+  bool _internal_has_keyid() const;
+  public:
+  void clear_keyid();
+  const ::proto::KeyId& keyid() const;
+  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
+  ::proto::KeyId* mutable_keyid();
+  void set_allocated_keyid(::proto::KeyId* keyid);
+  private:
+  const ::proto::KeyId& _internal_keyid() const;
+  ::proto::KeyId* _internal_mutable_keyid();
+  public:
+  void unsafe_arena_set_allocated_keyid(
+      ::proto::KeyId* keyid);
+  ::proto::KeyId* unsafe_arena_release_keyid();
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdSnapshot)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord > records_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_;
+    ::proto::SyncdVersion* version_;
+    ::proto::KeyId* keyid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdValue) */ {
+ public:
+  inline SyncdValue() : SyncdValue(nullptr) {}
+  ~SyncdValue() override;
+  explicit PROTOBUF_CONSTEXPR SyncdValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdValue(const SyncdValue& from);
+  SyncdValue(SyncdValue&& from) noexcept
+    : SyncdValue() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdValue& operator=(const SyncdValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdValue& operator=(SyncdValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdValue* internal_default_instance() {
+    return reinterpret_cast<const SyncdValue*>(
+               &_SyncdValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    211;
+
+  friend void swap(SyncdValue& a, SyncdValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdValue& from) {
+    SyncdValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdValue";
+  }
+  protected:
+  explicit SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBlobFieldNumber = 1,
+  };
+  // optional bytes blob = 1;
+  bool has_blob() const;
+  private:
+  bool _internal_has_blob() const;
+  public:
+  void clear_blob();
+  const std::string& blob() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_blob(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_blob();
+  PROTOBUF_NODISCARD std::string* release_blob();
+  void set_allocated_blob(std::string* blob);
+  private:
+  const std::string& _internal_blob() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value);
+  std::string* _internal_mutable_blob();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SyncdVersion final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdVersion) */ {
+ public:
+  inline SyncdVersion() : SyncdVersion(nullptr) {}
+  ~SyncdVersion() override;
+  explicit PROTOBUF_CONSTEXPR SyncdVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SyncdVersion(const SyncdVersion& from);
+  SyncdVersion(SyncdVersion&& from) noexcept
+    : SyncdVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline SyncdVersion& operator=(const SyncdVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SyncdVersion& operator=(SyncdVersion&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SyncdVersion& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SyncdVersion* internal_default_instance() {
+    return reinterpret_cast<const SyncdVersion*>(
+               &_SyncdVersion_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    212;
+
+  friend void swap(SyncdVersion& a, SyncdVersion& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SyncdVersion* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SyncdVersion* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SyncdVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SyncdVersion>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SyncdVersion& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SyncdVersion& from) {
+    SyncdVersion::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SyncdVersion* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.SyncdVersion";
+  }
+  protected:
+  explicit SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVersionFieldNumber = 1,
+  };
+  // optional uint64 version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  uint64_t version() const;
+  void set_version(uint64_t value);
+  private:
+  uint64_t _internal_version() const;
+  void _internal_set_version(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.SyncdVersion)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint64_t version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TemplateButton_CallButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.CallButton) */ {
+ public:
+  inline TemplateButton_CallButton() : TemplateButton_CallButton(nullptr) {}
+  ~TemplateButton_CallButton() override;
+  explicit PROTOBUF_CONSTEXPR TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TemplateButton_CallButton(const TemplateButton_CallButton& from);
+  TemplateButton_CallButton(TemplateButton_CallButton&& from) noexcept
+    : TemplateButton_CallButton() {
+    *this = ::std::move(from);
+  }
+
+  inline TemplateButton_CallButton& operator=(const TemplateButton_CallButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TemplateButton_CallButton& operator=(TemplateButton_CallButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TemplateButton_CallButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TemplateButton_CallButton* internal_default_instance() {
+    return reinterpret_cast<const TemplateButton_CallButton*>(
+               &_TemplateButton_CallButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    213;
+
+  friend void swap(TemplateButton_CallButton& a, TemplateButton_CallButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TemplateButton_CallButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TemplateButton_CallButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TemplateButton_CallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TemplateButton_CallButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TemplateButton_CallButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TemplateButton_CallButton& from) {
+    TemplateButton_CallButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TemplateButton_CallButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.TemplateButton.CallButton";
+  }
+  protected:
+  explicit TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+    kPhoneNumberFieldNumber = 2,
+  };
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
+  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
+  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
+  public:
+  void unsafe_arena_set_allocated_displaytext(
+      ::proto::Message_HighlyStructuredMessage* displaytext);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();
+
+  // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
+  bool has_phonenumber() const;
+  private:
+  bool _internal_has_phonenumber() const;
+  public:
+  void clear_phonenumber();
+  const ::proto::Message_HighlyStructuredMessage& phonenumber() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_phonenumber();
+  ::proto::Message_HighlyStructuredMessage* mutable_phonenumber();
+  void set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_phonenumber() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_phonenumber();
+  public:
+  void unsafe_arena_set_allocated_phonenumber(
+      ::proto::Message_HighlyStructuredMessage* phonenumber);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_phonenumber();
+
+  // @@protoc_insertion_point(class_scope:proto.TemplateButton.CallButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message_HighlyStructuredMessage* displaytext_;
+    ::proto::Message_HighlyStructuredMessage* phonenumber_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TemplateButton_QuickReplyButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.QuickReplyButton) */ {
+ public:
+  inline TemplateButton_QuickReplyButton() : TemplateButton_QuickReplyButton(nullptr) {}
+  ~TemplateButton_QuickReplyButton() override;
+  explicit PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from);
+  TemplateButton_QuickReplyButton(TemplateButton_QuickReplyButton&& from) noexcept
+    : TemplateButton_QuickReplyButton() {
+    *this = ::std::move(from);
+  }
+
+  inline TemplateButton_QuickReplyButton& operator=(const TemplateButton_QuickReplyButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TemplateButton_QuickReplyButton& operator=(TemplateButton_QuickReplyButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TemplateButton_QuickReplyButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TemplateButton_QuickReplyButton* internal_default_instance() {
+    return reinterpret_cast<const TemplateButton_QuickReplyButton*>(
+               &_TemplateButton_QuickReplyButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    214;
+
+  friend void swap(TemplateButton_QuickReplyButton& a, TemplateButton_QuickReplyButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TemplateButton_QuickReplyButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TemplateButton_QuickReplyButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TemplateButton_QuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TemplateButton_QuickReplyButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TemplateButton_QuickReplyButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TemplateButton_QuickReplyButton& from) {
+    TemplateButton_QuickReplyButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TemplateButton_QuickReplyButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.TemplateButton.QuickReplyButton";
+  }
+  protected:
+  explicit TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 2,
+    kDisplayTextFieldNumber = 1,
+  };
+  // optional string id = 2;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
+  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
+  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
+  public:
+  void unsafe_arena_set_allocated_displaytext(
+      ::proto::Message_HighlyStructuredMessage* displaytext);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();
+
+  // @@protoc_insertion_point(class_scope:proto.TemplateButton.QuickReplyButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::proto::Message_HighlyStructuredMessage* displaytext_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TemplateButton_URLButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.URLButton) */ {
+ public:
+  inline TemplateButton_URLButton() : TemplateButton_URLButton(nullptr) {}
+  ~TemplateButton_URLButton() override;
+  explicit PROTOBUF_CONSTEXPR TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TemplateButton_URLButton(const TemplateButton_URLButton& from);
+  TemplateButton_URLButton(TemplateButton_URLButton&& from) noexcept
+    : TemplateButton_URLButton() {
+    *this = ::std::move(from);
+  }
+
+  inline TemplateButton_URLButton& operator=(const TemplateButton_URLButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TemplateButton_URLButton& operator=(TemplateButton_URLButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TemplateButton_URLButton& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TemplateButton_URLButton* internal_default_instance() {
+    return reinterpret_cast<const TemplateButton_URLButton*>(
+               &_TemplateButton_URLButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    215;
+
+  friend void swap(TemplateButton_URLButton& a, TemplateButton_URLButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TemplateButton_URLButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TemplateButton_URLButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TemplateButton_URLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TemplateButton_URLButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TemplateButton_URLButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TemplateButton_URLButton& from) {
+    TemplateButton_URLButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TemplateButton_URLButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.TemplateButton.URLButton";
+  }
+  protected:
+  explicit TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayTextFieldNumber = 1,
+    kUrlFieldNumber = 2,
+  };
+  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
+  bool has_displaytext() const;
+  private:
+  bool _internal_has_displaytext() const;
+  public:
+  void clear_displaytext();
+  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
+  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
+  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
+  public:
+  void unsafe_arena_set_allocated_displaytext(
+      ::proto::Message_HighlyStructuredMessage* displaytext);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();
+
+  // optional .proto.Message.HighlyStructuredMessage url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const ::proto::Message_HighlyStructuredMessage& url() const;
+  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_url();
+  ::proto::Message_HighlyStructuredMessage* mutable_url();
+  void set_allocated_url(::proto::Message_HighlyStructuredMessage* url);
+  private:
+  const ::proto::Message_HighlyStructuredMessage& _internal_url() const;
+  ::proto::Message_HighlyStructuredMessage* _internal_mutable_url();
+  public:
+  void unsafe_arena_set_allocated_url(
+      ::proto::Message_HighlyStructuredMessage* url);
+  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_url();
+
+  // @@protoc_insertion_point(class_scope:proto.TemplateButton.URLButton)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::proto::Message_HighlyStructuredMessage* displaytext_;
+    ::proto::Message_HighlyStructuredMessage* url_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TemplateButton final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton) */ {
+ public:
+  inline TemplateButton() : TemplateButton(nullptr) {}
+  ~TemplateButton() override;
+  explicit PROTOBUF_CONSTEXPR TemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TemplateButton(const TemplateButton& from);
+  TemplateButton(TemplateButton&& from) noexcept
+    : TemplateButton() {
+    *this = ::std::move(from);
+  }
+
+  inline TemplateButton& operator=(const TemplateButton& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TemplateButton& operator=(TemplateButton&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TemplateButton& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ButtonCase {
+    kQuickReplyButton = 1,
+    kUrlButton = 2,
+    kCallButton = 3,
+    BUTTON_NOT_SET = 0,
+  };
+
+  static inline const TemplateButton* internal_default_instance() {
+    return reinterpret_cast<const TemplateButton*>(
+               &_TemplateButton_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    216;
+
+  friend void swap(TemplateButton& a, TemplateButton& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TemplateButton* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TemplateButton* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TemplateButton>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TemplateButton& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TemplateButton& from) {
+    TemplateButton::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TemplateButton* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.TemplateButton";
+  }
+  protected:
+  explicit TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef TemplateButton_CallButton CallButton;
+  typedef TemplateButton_QuickReplyButton QuickReplyButton;
+  typedef TemplateButton_URLButton URLButton;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndexFieldNumber = 4,
+    kQuickReplyButtonFieldNumber = 1,
+    kUrlButtonFieldNumber = 2,
+    kCallButtonFieldNumber = 3,
+  };
+  // optional uint32 index = 4;
+  bool has_index() const;
+  private:
+  bool _internal_has_index() const;
+  public:
+  void clear_index();
+  uint32_t index() const;
+  void set_index(uint32_t value);
+  private:
+  uint32_t _internal_index() const;
+  void _internal_set_index(uint32_t value);
+  public:
+
+  // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
+  bool has_quickreplybutton() const;
+  private:
+  bool _internal_has_quickreplybutton() const;
+  public:
+  void clear_quickreplybutton();
+  const ::proto::TemplateButton_QuickReplyButton& quickreplybutton() const;
+  PROTOBUF_NODISCARD ::proto::TemplateButton_QuickReplyButton* release_quickreplybutton();
+  ::proto::TemplateButton_QuickReplyButton* mutable_quickreplybutton();
+  void set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton);
+  private:
+  const ::proto::TemplateButton_QuickReplyButton& _internal_quickreplybutton() const;
+  ::proto::TemplateButton_QuickReplyButton* _internal_mutable_quickreplybutton();
+  public:
+  void unsafe_arena_set_allocated_quickreplybutton(
+      ::proto::TemplateButton_QuickReplyButton* quickreplybutton);
+  ::proto::TemplateButton_QuickReplyButton* unsafe_arena_release_quickreplybutton();
+
+  // .proto.TemplateButton.URLButton urlButton = 2;
+  bool has_urlbutton() const;
+  private:
+  bool _internal_has_urlbutton() const;
+  public:
+  void clear_urlbutton();
+  const ::proto::TemplateButton_URLButton& urlbutton() const;
+  PROTOBUF_NODISCARD ::proto::TemplateButton_URLButton* release_urlbutton();
+  ::proto::TemplateButton_URLButton* mutable_urlbutton();
+  void set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton);
+  private:
+  const ::proto::TemplateButton_URLButton& _internal_urlbutton() const;
+  ::proto::TemplateButton_URLButton* _internal_mutable_urlbutton();
+  public:
+  void unsafe_arena_set_allocated_urlbutton(
+      ::proto::TemplateButton_URLButton* urlbutton);
+  ::proto::TemplateButton_URLButton* unsafe_arena_release_urlbutton();
+
+  // .proto.TemplateButton.CallButton callButton = 3;
+  bool has_callbutton() const;
+  private:
+  bool _internal_has_callbutton() const;
+  public:
+  void clear_callbutton();
+  const ::proto::TemplateButton_CallButton& callbutton() const;
+  PROTOBUF_NODISCARD ::proto::TemplateButton_CallButton* release_callbutton();
+  ::proto::TemplateButton_CallButton* mutable_callbutton();
+  void set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton);
+  private:
+  const ::proto::TemplateButton_CallButton& _internal_callbutton() const;
+  ::proto::TemplateButton_CallButton* _internal_mutable_callbutton();
+  public:
+  void unsafe_arena_set_allocated_callbutton(
+      ::proto::TemplateButton_CallButton* callbutton);
+  ::proto::TemplateButton_CallButton* unsafe_arena_release_callbutton();
+
+  void clear_button();
+  ButtonCase button_case() const;
+  // @@protoc_insertion_point(class_scope:proto.TemplateButton)
+ private:
+  class _Internal;
+  void set_has_quickreplybutton();
+  void set_has_urlbutton();
+  void set_has_callbutton();
+
+  inline bool has_button() const;
+  inline void clear_has_button();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t index_;
+    union ButtonUnion {
+      constexpr ButtonUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::proto::TemplateButton_QuickReplyButton* quickreplybutton_;
+      ::proto::TemplateButton_URLButton* urlbutton_;
+      ::proto::TemplateButton_CallButton* callbutton_;
+    } button_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class UserReceipt final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.UserReceipt) */ {
+ public:
+  inline UserReceipt() : UserReceipt(nullptr) {}
+  ~UserReceipt() override;
+  explicit PROTOBUF_CONSTEXPR UserReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UserReceipt(const UserReceipt& from);
+  UserReceipt(UserReceipt&& from) noexcept
+    : UserReceipt() {
+    *this = ::std::move(from);
+  }
+
+  inline UserReceipt& operator=(const UserReceipt& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UserReceipt& operator=(UserReceipt&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UserReceipt& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UserReceipt* internal_default_instance() {
+    return reinterpret_cast<const UserReceipt*>(
+               &_UserReceipt_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    217;
+
+  friend void swap(UserReceipt& a, UserReceipt& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UserReceipt* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UserReceipt* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UserReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UserReceipt>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UserReceipt& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UserReceipt& from) {
+    UserReceipt::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UserReceipt* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.UserReceipt";
+  }
+  protected:
+  explicit UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPendingDeviceJidFieldNumber = 5,
+    kDeliveredDeviceJidFieldNumber = 6,
+    kUserJidFieldNumber = 1,
+    kReceiptTimestampFieldNumber = 2,
+    kReadTimestampFieldNumber = 3,
+    kPlayedTimestampFieldNumber = 4,
+  };
+  // repeated string pendingDeviceJid = 5;
+  int pendingdevicejid_size() const;
+  private:
+  int _internal_pendingdevicejid_size() const;
+  public:
+  void clear_pendingdevicejid();
+  const std::string& pendingdevicejid(int index) const;
+  std::string* mutable_pendingdevicejid(int index);
+  void set_pendingdevicejid(int index, const std::string& value);
+  void set_pendingdevicejid(int index, std::string&& value);
+  void set_pendingdevicejid(int index, const char* value);
+  void set_pendingdevicejid(int index, const char* value, size_t size);
+  std::string* add_pendingdevicejid();
+  void add_pendingdevicejid(const std::string& value);
+  void add_pendingdevicejid(std::string&& value);
+  void add_pendingdevicejid(const char* value);
+  void add_pendingdevicejid(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& pendingdevicejid() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_pendingdevicejid();
+  private:
+  const std::string& _internal_pendingdevicejid(int index) const;
+  std::string* _internal_add_pendingdevicejid();
+  public:
+
+  // repeated string deliveredDeviceJid = 6;
+  int delivereddevicejid_size() const;
+  private:
+  int _internal_delivereddevicejid_size() const;
+  public:
+  void clear_delivereddevicejid();
+  const std::string& delivereddevicejid(int index) const;
+  std::string* mutable_delivereddevicejid(int index);
+  void set_delivereddevicejid(int index, const std::string& value);
+  void set_delivereddevicejid(int index, std::string&& value);
+  void set_delivereddevicejid(int index, const char* value);
+  void set_delivereddevicejid(int index, const char* value, size_t size);
+  std::string* add_delivereddevicejid();
+  void add_delivereddevicejid(const std::string& value);
+  void add_delivereddevicejid(std::string&& value);
+  void add_delivereddevicejid(const char* value);
+  void add_delivereddevicejid(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& delivereddevicejid() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_delivereddevicejid();
+  private:
+  const std::string& _internal_delivereddevicejid(int index) const;
+  std::string* _internal_add_delivereddevicejid();
+  public:
+
+  // required string userJid = 1;
+  bool has_userjid() const;
+  private:
+  bool _internal_has_userjid() const;
+  public:
+  void clear_userjid();
+  const std::string& userjid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_userjid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_userjid();
+  PROTOBUF_NODISCARD std::string* release_userjid();
+  void set_allocated_userjid(std::string* userjid);
+  private:
+  const std::string& _internal_userjid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
+  std::string* _internal_mutable_userjid();
+  public:
+
+  // optional int64 receiptTimestamp = 2;
+  bool has_receipttimestamp() const;
+  private:
+  bool _internal_has_receipttimestamp() const;
+  public:
+  void clear_receipttimestamp();
+  int64_t receipttimestamp() const;
+  void set_receipttimestamp(int64_t value);
+  private:
+  int64_t _internal_receipttimestamp() const;
+  void _internal_set_receipttimestamp(int64_t value);
+  public:
+
+  // optional int64 readTimestamp = 3;
+  bool has_readtimestamp() const;
+  private:
+  bool _internal_has_readtimestamp() const;
+  public:
+  void clear_readtimestamp();
+  int64_t readtimestamp() const;
+  void set_readtimestamp(int64_t value);
+  private:
+  int64_t _internal_readtimestamp() const;
+  void _internal_set_readtimestamp(int64_t value);
+  public:
+
+  // optional int64 playedTimestamp = 4;
+  bool has_playedtimestamp() const;
+  private:
+  bool _internal_has_playedtimestamp() const;
+  public:
+  void clear_playedtimestamp();
+  int64_t playedtimestamp() const;
+  void set_playedtimestamp(int64_t value);
+  private:
+  int64_t _internal_playedtimestamp() const;
+  void _internal_set_playedtimestamp(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.UserReceipt)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> pendingdevicejid_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> delivereddevicejid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_;
+    int64_t receipttimestamp_;
+    int64_t readtimestamp_;
+    int64_t playedtimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VerifiedNameCertificate_Details final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate.Details) */ {
+ public:
+  inline VerifiedNameCertificate_Details() : VerifiedNameCertificate_Details(nullptr) {}
+  ~VerifiedNameCertificate_Details() override;
+  explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from);
+  VerifiedNameCertificate_Details(VerifiedNameCertificate_Details&& from) noexcept
+    : VerifiedNameCertificate_Details() {
+    *this = ::std::move(from);
+  }
+
+  inline VerifiedNameCertificate_Details& operator=(const VerifiedNameCertificate_Details& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VerifiedNameCertificate_Details& operator=(VerifiedNameCertificate_Details&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VerifiedNameCertificate_Details& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VerifiedNameCertificate_Details* internal_default_instance() {
+    return reinterpret_cast<const VerifiedNameCertificate_Details*>(
+               &_VerifiedNameCertificate_Details_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    218;
+
+  friend void swap(VerifiedNameCertificate_Details& a, VerifiedNameCertificate_Details& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VerifiedNameCertificate_Details* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VerifiedNameCertificate_Details* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VerifiedNameCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VerifiedNameCertificate_Details>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VerifiedNameCertificate_Details& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VerifiedNameCertificate_Details& from) {
+    VerifiedNameCertificate_Details::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VerifiedNameCertificate_Details* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.VerifiedNameCertificate.Details";
+  }
+  protected:
+  explicit VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLocalizedNamesFieldNumber = 8,
+    kIssuerFieldNumber = 2,
+    kVerifiedNameFieldNumber = 4,
+    kSerialFieldNumber = 1,
+    kIssueTimeFieldNumber = 10,
+  };
+  // repeated .proto.LocalizedName localizedNames = 8;
+  int localizednames_size() const;
+  private:
+  int _internal_localizednames_size() const;
+  public:
+  void clear_localizednames();
+  ::proto::LocalizedName* mutable_localizednames(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >*
+      mutable_localizednames();
+  private:
+  const ::proto::LocalizedName& _internal_localizednames(int index) const;
+  ::proto::LocalizedName* _internal_add_localizednames();
+  public:
+  const ::proto::LocalizedName& localizednames(int index) const;
+  ::proto::LocalizedName* add_localizednames();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >&
+      localizednames() const;
+
+  // optional string issuer = 2;
+  bool has_issuer() const;
+  private:
+  bool _internal_has_issuer() const;
+  public:
+  void clear_issuer();
+  const std::string& issuer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_issuer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_issuer();
+  PROTOBUF_NODISCARD std::string* release_issuer();
+  void set_allocated_issuer(std::string* issuer);
+  private:
+  const std::string& _internal_issuer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value);
+  std::string* _internal_mutable_issuer();
+  public:
+
+  // optional string verifiedName = 4;
+  bool has_verifiedname() const;
+  private:
+  bool _internal_has_verifiedname() const;
+  public:
+  void clear_verifiedname();
+  const std::string& verifiedname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_verifiedname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_verifiedname();
+  PROTOBUF_NODISCARD std::string* release_verifiedname();
+  void set_allocated_verifiedname(std::string* verifiedname);
+  private:
+  const std::string& _internal_verifiedname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value);
+  std::string* _internal_mutable_verifiedname();
+  public:
+
+  // optional uint64 serial = 1;
+  bool has_serial() const;
+  private:
+  bool _internal_has_serial() const;
+  public:
+  void clear_serial();
+  uint64_t serial() const;
+  void set_serial(uint64_t value);
+  private:
+  uint64_t _internal_serial() const;
+  void _internal_set_serial(uint64_t value);
+  public:
+
+  // optional uint64 issueTime = 10;
+  bool has_issuetime() const;
+  private:
+  bool _internal_has_issuetime() const;
+  public:
+  void clear_issuetime();
+  uint64_t issuetime() const;
+  void set_issuetime(uint64_t value);
+  private:
+  uint64_t _internal_issuetime() const;
+  void _internal_set_issuetime(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate.Details)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName > localizednames_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_;
+    uint64_t serial_;
+    uint64_t issuetime_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VerifiedNameCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate) */ {
+ public:
+  inline VerifiedNameCertificate() : VerifiedNameCertificate(nullptr) {}
+  ~VerifiedNameCertificate() override;
+  explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VerifiedNameCertificate(const VerifiedNameCertificate& from);
+  VerifiedNameCertificate(VerifiedNameCertificate&& from) noexcept
+    : VerifiedNameCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline VerifiedNameCertificate& operator=(const VerifiedNameCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VerifiedNameCertificate& operator=(VerifiedNameCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VerifiedNameCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VerifiedNameCertificate* internal_default_instance() {
+    return reinterpret_cast<const VerifiedNameCertificate*>(
+               &_VerifiedNameCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    219;
+
+  friend void swap(VerifiedNameCertificate& a, VerifiedNameCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VerifiedNameCertificate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VerifiedNameCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VerifiedNameCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VerifiedNameCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VerifiedNameCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VerifiedNameCertificate& from) {
+    VerifiedNameCertificate::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VerifiedNameCertificate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.VerifiedNameCertificate";
+  }
+  protected:
+  explicit VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef VerifiedNameCertificate_Details Details;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailsFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kServerSignatureFieldNumber = 3,
+  };
+  // optional bytes details = 1;
+  bool has_details() const;
+  private:
+  bool _internal_has_details() const;
+  public:
+  void clear_details();
+  const std::string& details() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_details(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_details();
+  PROTOBUF_NODISCARD std::string* release_details();
+  void set_allocated_details(std::string* details);
+  private:
+  const std::string& _internal_details() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
+  std::string* _internal_mutable_details();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_NODISCARD std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional bytes serverSignature = 3;
+  bool has_serversignature() const;
+  private:
+  bool _internal_has_serversignature() const;
+  public:
+  void clear_serversignature();
+  const std::string& serversignature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_serversignature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_serversignature();
+  PROTOBUF_NODISCARD std::string* release_serversignature();
+  void set_allocated_serversignature(std::string* serversignature);
+  private:
+  const std::string& _internal_serversignature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serversignature(const std::string& value);
+  std::string* _internal_mutable_serversignature();
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serversignature_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WallpaperSettings final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WallpaperSettings) */ {
+ public:
+  inline WallpaperSettings() : WallpaperSettings(nullptr) {}
+  ~WallpaperSettings() override;
+  explicit PROTOBUF_CONSTEXPR WallpaperSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WallpaperSettings(const WallpaperSettings& from);
+  WallpaperSettings(WallpaperSettings&& from) noexcept
+    : WallpaperSettings() {
+    *this = ::std::move(from);
+  }
+
+  inline WallpaperSettings& operator=(const WallpaperSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WallpaperSettings& operator=(WallpaperSettings&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WallpaperSettings& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WallpaperSettings* internal_default_instance() {
+    return reinterpret_cast<const WallpaperSettings*>(
+               &_WallpaperSettings_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    220;
+
+  friend void swap(WallpaperSettings& a, WallpaperSettings& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WallpaperSettings* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WallpaperSettings* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  WallpaperSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<WallpaperSettings>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WallpaperSettings& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const WallpaperSettings& from) {
+    WallpaperSettings::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WallpaperSettings* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.WallpaperSettings";
+  }
+  protected:
+  explicit WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFilenameFieldNumber = 1,
+    kOpacityFieldNumber = 2,
+  };
+  // optional string filename = 1;
+  bool has_filename() const;
+  private:
+  bool _internal_has_filename() const;
+  public:
+  void clear_filename();
+  const std::string& filename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_filename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_filename();
+  PROTOBUF_NODISCARD std::string* release_filename();
+  void set_allocated_filename(std::string* filename);
+  private:
+  const std::string& _internal_filename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
+  std::string* _internal_mutable_filename();
+  public:
+
+  // optional uint32 opacity = 2;
+  bool has_opacity() const;
+  private:
+  bool _internal_has_opacity() const;
+  public:
+  void clear_opacity();
+  uint32_t opacity() const;
+  void set_opacity(uint32_t value);
+  private:
+  uint32_t _internal_opacity() const;
+  void _internal_set_opacity(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.WallpaperSettings)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
+    uint32_t opacity_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WebFeatures final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebFeatures) */ {
+ public:
+  inline WebFeatures() : WebFeatures(nullptr) {}
+  ~WebFeatures() override;
+  explicit PROTOBUF_CONSTEXPR WebFeatures(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WebFeatures(const WebFeatures& from);
+  WebFeatures(WebFeatures&& from) noexcept
+    : WebFeatures() {
+    *this = ::std::move(from);
+  }
+
+  inline WebFeatures& operator=(const WebFeatures& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WebFeatures& operator=(WebFeatures&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WebFeatures& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WebFeatures* internal_default_instance() {
+    return reinterpret_cast<const WebFeatures*>(
+               &_WebFeatures_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    221;
+
+  friend void swap(WebFeatures& a, WebFeatures& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WebFeatures* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WebFeatures* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  WebFeatures* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<WebFeatures>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WebFeatures& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const WebFeatures& from) {
+    WebFeatures::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WebFeatures* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.WebFeatures";
+  }
+  protected:
+  explicit WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef WebFeatures_Flag Flag;
+  static constexpr Flag NOT_STARTED =
+    WebFeatures_Flag_NOT_STARTED;
+  static constexpr Flag FORCE_UPGRADE =
+    WebFeatures_Flag_FORCE_UPGRADE;
+  static constexpr Flag DEVELOPMENT =
+    WebFeatures_Flag_DEVELOPMENT;
+  static constexpr Flag PRODUCTION =
+    WebFeatures_Flag_PRODUCTION;
+  static inline bool Flag_IsValid(int value) {
+    return WebFeatures_Flag_IsValid(value);
+  }
+  static constexpr Flag Flag_MIN =
+    WebFeatures_Flag_Flag_MIN;
+  static constexpr Flag Flag_MAX =
+    WebFeatures_Flag_Flag_MAX;
+  static constexpr int Flag_ARRAYSIZE =
+    WebFeatures_Flag_Flag_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Flag_descriptor() {
+    return WebFeatures_Flag_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Flag_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Flag>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Flag_Name.");
+    return WebFeatures_Flag_Name(enum_t_value);
+  }
+  static inline bool Flag_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Flag* value) {
+    return WebFeatures_Flag_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLabelsDisplayFieldNumber = 1,
+    kVoipIndividualOutgoingFieldNumber = 2,
+    kGroupsV3FieldNumber = 3,
+    kGroupsV3CreateFieldNumber = 4,
+    kChangeNumberV2FieldNumber = 5,
+    kQueryStatusV3ThumbnailFieldNumber = 6,
+    kLiveLocationsFieldNumber = 7,
+    kQueryVnameFieldNumber = 8,
+    kVoipIndividualIncomingFieldNumber = 9,
+    kQuickRepliesQueryFieldNumber = 10,
+    kPaymentsFieldNumber = 11,
+    kStickerPackQueryFieldNumber = 12,
+    kLiveLocationsFinalFieldNumber = 13,
+    kLabelsEditFieldNumber = 14,
+    kMediaUploadFieldNumber = 15,
+    kMediaUploadRichQuickRepliesFieldNumber = 18,
+    kVnameV2FieldNumber = 19,
+    kVideoPlaybackUrlFieldNumber = 20,
+    kStatusRankingFieldNumber = 21,
+    kVoipIndividualVideoFieldNumber = 22,
+    kThirdPartyStickersFieldNumber = 23,
+    kFrequentlyForwardedSettingFieldNumber = 24,
+    kGroupsV4JoinPermissionFieldNumber = 25,
+    kRecentStickersFieldNumber = 26,
+    kCatalogFieldNumber = 27,
+    kStarredStickersFieldNumber = 28,
+    kVoipGroupCallFieldNumber = 29,
+    kTemplateMessageFieldNumber = 30,
+    kTemplateMessageInteractivityFieldNumber = 31,
+    kEphemeralMessagesFieldNumber = 32,
+    kE2ENotificationSyncFieldNumber = 33,
+    kRecentStickersV2FieldNumber = 34,
+    kRecentStickersV3FieldNumber = 36,
+    kUserNoticeFieldNumber = 37,
+    kSupportFieldNumber = 39,
+    kGroupUiiCleanupFieldNumber = 40,
+    kGroupDogfoodingInternalOnlyFieldNumber = 41,
+    kSettingsSyncFieldNumber = 42,
+    kArchiveV2FieldNumber = 43,
+    kEphemeralAllowGroupMembersFieldNumber = 44,
+    kEphemeral24HDurationFieldNumber = 45,
+    kMdForceUpgradeFieldNumber = 46,
+    kDisappearingModeFieldNumber = 47,
+    kExternalMdOptInAvailableFieldNumber = 48,
+    kNoDeleteMessageTimeLimitFieldNumber = 49,
+  };
+  // optional .proto.WebFeatures.Flag labelsDisplay = 1;
+  bool has_labelsdisplay() const;
+  private:
+  bool _internal_has_labelsdisplay() const;
+  public:
+  void clear_labelsdisplay();
+  ::proto::WebFeatures_Flag labelsdisplay() const;
+  void set_labelsdisplay(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_labelsdisplay() const;
+  void _internal_set_labelsdisplay(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
+  bool has_voipindividualoutgoing() const;
+  private:
+  bool _internal_has_voipindividualoutgoing() const;
+  public:
+  void clear_voipindividualoutgoing();
+  ::proto::WebFeatures_Flag voipindividualoutgoing() const;
+  void set_voipindividualoutgoing(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_voipindividualoutgoing() const;
+  void _internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag groupsV3 = 3;
+  bool has_groupsv3() const;
+  private:
+  bool _internal_has_groupsv3() const;
+  public:
+  void clear_groupsv3();
+  ::proto::WebFeatures_Flag groupsv3() const;
+  void set_groupsv3(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_groupsv3() const;
+  void _internal_set_groupsv3(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag groupsV3Create = 4;
+  bool has_groupsv3create() const;
+  private:
+  bool _internal_has_groupsv3create() const;
+  public:
+  void clear_groupsv3create();
+  ::proto::WebFeatures_Flag groupsv3create() const;
+  void set_groupsv3create(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_groupsv3create() const;
+  void _internal_set_groupsv3create(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag changeNumberV2 = 5;
+  bool has_changenumberv2() const;
+  private:
+  bool _internal_has_changenumberv2() const;
+  public:
+  void clear_changenumberv2();
+  ::proto::WebFeatures_Flag changenumberv2() const;
+  void set_changenumberv2(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_changenumberv2() const;
+  void _internal_set_changenumberv2(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
+  bool has_querystatusv3thumbnail() const;
+  private:
+  bool _internal_has_querystatusv3thumbnail() const;
+  public:
+  void clear_querystatusv3thumbnail();
+  ::proto::WebFeatures_Flag querystatusv3thumbnail() const;
+  void set_querystatusv3thumbnail(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_querystatusv3thumbnail() const;
+  void _internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag liveLocations = 7;
+  bool has_livelocations() const;
+  private:
+  bool _internal_has_livelocations() const;
+  public:
+  void clear_livelocations();
+  ::proto::WebFeatures_Flag livelocations() const;
+  void set_livelocations(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_livelocations() const;
+  void _internal_set_livelocations(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag queryVname = 8;
+  bool has_queryvname() const;
+  private:
+  bool _internal_has_queryvname() const;
+  public:
+  void clear_queryvname();
+  ::proto::WebFeatures_Flag queryvname() const;
+  void set_queryvname(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_queryvname() const;
+  void _internal_set_queryvname(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
+  bool has_voipindividualincoming() const;
+  private:
+  bool _internal_has_voipindividualincoming() const;
+  public:
+  void clear_voipindividualincoming();
+  ::proto::WebFeatures_Flag voipindividualincoming() const;
+  void set_voipindividualincoming(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_voipindividualincoming() const;
+  void _internal_set_voipindividualincoming(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
+  bool has_quickrepliesquery() const;
+  private:
+  bool _internal_has_quickrepliesquery() const;
+  public:
+  void clear_quickrepliesquery();
+  ::proto::WebFeatures_Flag quickrepliesquery() const;
+  void set_quickrepliesquery(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_quickrepliesquery() const;
+  void _internal_set_quickrepliesquery(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag payments = 11;
+  bool has_payments() const;
+  private:
+  bool _internal_has_payments() const;
+  public:
+  void clear_payments();
+  ::proto::WebFeatures_Flag payments() const;
+  void set_payments(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_payments() const;
+  void _internal_set_payments(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag stickerPackQuery = 12;
+  bool has_stickerpackquery() const;
+  private:
+  bool _internal_has_stickerpackquery() const;
+  public:
+  void clear_stickerpackquery();
+  ::proto::WebFeatures_Flag stickerpackquery() const;
+  void set_stickerpackquery(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_stickerpackquery() const;
+  void _internal_set_stickerpackquery(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
+  bool has_livelocationsfinal() const;
+  private:
+  bool _internal_has_livelocationsfinal() const;
+  public:
+  void clear_livelocationsfinal();
+  ::proto::WebFeatures_Flag livelocationsfinal() const;
+  void set_livelocationsfinal(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_livelocationsfinal() const;
+  void _internal_set_livelocationsfinal(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag labelsEdit = 14;
+  bool has_labelsedit() const;
+  private:
+  bool _internal_has_labelsedit() const;
+  public:
+  void clear_labelsedit();
+  ::proto::WebFeatures_Flag labelsedit() const;
+  void set_labelsedit(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_labelsedit() const;
+  void _internal_set_labelsedit(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag mediaUpload = 15;
+  bool has_mediaupload() const;
+  private:
+  bool _internal_has_mediaupload() const;
+  public:
+  void clear_mediaupload();
+  ::proto::WebFeatures_Flag mediaupload() const;
+  void set_mediaupload(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_mediaupload() const;
+  void _internal_set_mediaupload(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
+  bool has_mediauploadrichquickreplies() const;
+  private:
+  bool _internal_has_mediauploadrichquickreplies() const;
+  public:
+  void clear_mediauploadrichquickreplies();
+  ::proto::WebFeatures_Flag mediauploadrichquickreplies() const;
+  void set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_mediauploadrichquickreplies() const;
+  void _internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag vnameV2 = 19;
+  bool has_vnamev2() const;
+  private:
+  bool _internal_has_vnamev2() const;
+  public:
+  void clear_vnamev2();
+  ::proto::WebFeatures_Flag vnamev2() const;
+  void set_vnamev2(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_vnamev2() const;
+  void _internal_set_vnamev2(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
+  bool has_videoplaybackurl() const;
+  private:
+  bool _internal_has_videoplaybackurl() const;
+  public:
+  void clear_videoplaybackurl();
+  ::proto::WebFeatures_Flag videoplaybackurl() const;
+  void set_videoplaybackurl(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_videoplaybackurl() const;
+  void _internal_set_videoplaybackurl(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag statusRanking = 21;
+  bool has_statusranking() const;
+  private:
+  bool _internal_has_statusranking() const;
+  public:
+  void clear_statusranking();
+  ::proto::WebFeatures_Flag statusranking() const;
+  void set_statusranking(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_statusranking() const;
+  void _internal_set_statusranking(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
+  bool has_voipindividualvideo() const;
+  private:
+  bool _internal_has_voipindividualvideo() const;
+  public:
+  void clear_voipindividualvideo();
+  ::proto::WebFeatures_Flag voipindividualvideo() const;
+  void set_voipindividualvideo(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_voipindividualvideo() const;
+  void _internal_set_voipindividualvideo(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
+  bool has_thirdpartystickers() const;
+  private:
+  bool _internal_has_thirdpartystickers() const;
+  public:
+  void clear_thirdpartystickers();
+  ::proto::WebFeatures_Flag thirdpartystickers() const;
+  void set_thirdpartystickers(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_thirdpartystickers() const;
+  void _internal_set_thirdpartystickers(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
+  bool has_frequentlyforwardedsetting() const;
+  private:
+  bool _internal_has_frequentlyforwardedsetting() const;
+  public:
+  void clear_frequentlyforwardedsetting();
+  ::proto::WebFeatures_Flag frequentlyforwardedsetting() const;
+  void set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_frequentlyforwardedsetting() const;
+  void _internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
+  bool has_groupsv4joinpermission() const;
+  private:
+  bool _internal_has_groupsv4joinpermission() const;
+  public:
+  void clear_groupsv4joinpermission();
+  ::proto::WebFeatures_Flag groupsv4joinpermission() const;
+  void set_groupsv4joinpermission(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_groupsv4joinpermission() const;
+  void _internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag recentStickers = 26;
+  bool has_recentstickers() const;
+  private:
+  bool _internal_has_recentstickers() const;
+  public:
+  void clear_recentstickers();
+  ::proto::WebFeatures_Flag recentstickers() const;
+  void set_recentstickers(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_recentstickers() const;
+  void _internal_set_recentstickers(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag catalog = 27;
+  bool has_catalog() const;
+  private:
+  bool _internal_has_catalog() const;
+  public:
+  void clear_catalog();
+  ::proto::WebFeatures_Flag catalog() const;
+  void set_catalog(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_catalog() const;
+  void _internal_set_catalog(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag starredStickers = 28;
+  bool has_starredstickers() const;
+  private:
+  bool _internal_has_starredstickers() const;
+  public:
+  void clear_starredstickers();
+  ::proto::WebFeatures_Flag starredstickers() const;
+  void set_starredstickers(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_starredstickers() const;
+  void _internal_set_starredstickers(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag voipGroupCall = 29;
+  bool has_voipgroupcall() const;
+  private:
+  bool _internal_has_voipgroupcall() const;
+  public:
+  void clear_voipgroupcall();
+  ::proto::WebFeatures_Flag voipgroupcall() const;
+  void set_voipgroupcall(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_voipgroupcall() const;
+  void _internal_set_voipgroupcall(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag templateMessage = 30;
+  bool has_templatemessage() const;
+  private:
+  bool _internal_has_templatemessage() const;
+  public:
+  void clear_templatemessage();
+  ::proto::WebFeatures_Flag templatemessage() const;
+  void set_templatemessage(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_templatemessage() const;
+  void _internal_set_templatemessage(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
+  bool has_templatemessageinteractivity() const;
+  private:
+  bool _internal_has_templatemessageinteractivity() const;
+  public:
+  void clear_templatemessageinteractivity();
+  ::proto::WebFeatures_Flag templatemessageinteractivity() const;
+  void set_templatemessageinteractivity(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_templatemessageinteractivity() const;
+  void _internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag ephemeralMessages = 32;
+  bool has_ephemeralmessages() const;
+  private:
+  bool _internal_has_ephemeralmessages() const;
+  public:
+  void clear_ephemeralmessages();
+  ::proto::WebFeatures_Flag ephemeralmessages() const;
+  void set_ephemeralmessages(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_ephemeralmessages() const;
+  void _internal_set_ephemeralmessages(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
+  bool has_e2enotificationsync() const;
+  private:
+  bool _internal_has_e2enotificationsync() const;
+  public:
+  void clear_e2enotificationsync();
+  ::proto::WebFeatures_Flag e2enotificationsync() const;
+  void set_e2enotificationsync(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_e2enotificationsync() const;
+  void _internal_set_e2enotificationsync(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag recentStickersV2 = 34;
+  bool has_recentstickersv2() const;
+  private:
+  bool _internal_has_recentstickersv2() const;
+  public:
+  void clear_recentstickersv2();
+  ::proto::WebFeatures_Flag recentstickersv2() const;
+  void set_recentstickersv2(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_recentstickersv2() const;
+  void _internal_set_recentstickersv2(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag recentStickersV3 = 36;
+  bool has_recentstickersv3() const;
+  private:
+  bool _internal_has_recentstickersv3() const;
+  public:
+  void clear_recentstickersv3();
+  ::proto::WebFeatures_Flag recentstickersv3() const;
+  void set_recentstickersv3(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_recentstickersv3() const;
+  void _internal_set_recentstickersv3(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag userNotice = 37;
+  bool has_usernotice() const;
+  private:
+  bool _internal_has_usernotice() const;
+  public:
+  void clear_usernotice();
+  ::proto::WebFeatures_Flag usernotice() const;
+  void set_usernotice(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_usernotice() const;
+  void _internal_set_usernotice(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag support = 39;
+  bool has_support() const;
+  private:
+  bool _internal_has_support() const;
+  public:
+  void clear_support();
+  ::proto::WebFeatures_Flag support() const;
+  void set_support(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_support() const;
+  void _internal_set_support(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
+  bool has_groupuiicleanup() const;
+  private:
+  bool _internal_has_groupuiicleanup() const;
+  public:
+  void clear_groupuiicleanup();
+  ::proto::WebFeatures_Flag groupuiicleanup() const;
+  void set_groupuiicleanup(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_groupuiicleanup() const;
+  void _internal_set_groupuiicleanup(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
+  bool has_groupdogfoodinginternalonly() const;
+  private:
+  bool _internal_has_groupdogfoodinginternalonly() const;
+  public:
+  void clear_groupdogfoodinginternalonly();
+  ::proto::WebFeatures_Flag groupdogfoodinginternalonly() const;
+  void set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_groupdogfoodinginternalonly() const;
+  void _internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag settingsSync = 42;
+  bool has_settingssync() const;
+  private:
+  bool _internal_has_settingssync() const;
+  public:
+  void clear_settingssync();
+  ::proto::WebFeatures_Flag settingssync() const;
+  void set_settingssync(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_settingssync() const;
+  void _internal_set_settingssync(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag archiveV2 = 43;
+  bool has_archivev2() const;
+  private:
+  bool _internal_has_archivev2() const;
+  public:
+  void clear_archivev2();
+  ::proto::WebFeatures_Flag archivev2() const;
+  void set_archivev2(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_archivev2() const;
+  void _internal_set_archivev2(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
+  bool has_ephemeralallowgroupmembers() const;
+  private:
+  bool _internal_has_ephemeralallowgroupmembers() const;
+  public:
+  void clear_ephemeralallowgroupmembers();
+  ::proto::WebFeatures_Flag ephemeralallowgroupmembers() const;
+  void set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_ephemeralallowgroupmembers() const;
+  void _internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
+  bool has_ephemeral24hduration() const;
+  private:
+  bool _internal_has_ephemeral24hduration() const;
+  public:
+  void clear_ephemeral24hduration();
+  ::proto::WebFeatures_Flag ephemeral24hduration() const;
+  void set_ephemeral24hduration(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_ephemeral24hduration() const;
+  void _internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
+  bool has_mdforceupgrade() const;
+  private:
+  bool _internal_has_mdforceupgrade() const;
+  public:
+  void clear_mdforceupgrade();
+  ::proto::WebFeatures_Flag mdforceupgrade() const;
+  void set_mdforceupgrade(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_mdforceupgrade() const;
+  void _internal_set_mdforceupgrade(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag disappearingMode = 47;
+  bool has_disappearingmode() const;
+  private:
+  bool _internal_has_disappearingmode() const;
+  public:
+  void clear_disappearingmode();
+  ::proto::WebFeatures_Flag disappearingmode() const;
+  void set_disappearingmode(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_disappearingmode() const;
+  void _internal_set_disappearingmode(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
+  bool has_externalmdoptinavailable() const;
+  private:
+  bool _internal_has_externalmdoptinavailable() const;
+  public:
+  void clear_externalmdoptinavailable();
+  ::proto::WebFeatures_Flag externalmdoptinavailable() const;
+  void set_externalmdoptinavailable(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_externalmdoptinavailable() const;
+  void _internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value);
+  public:
+
+  // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
+  bool has_nodeletemessagetimelimit() const;
+  private:
+  bool _internal_has_nodeletemessagetimelimit() const;
+  public:
+  void clear_nodeletemessagetimelimit();
+  ::proto::WebFeatures_Flag nodeletemessagetimelimit() const;
+  void set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value);
+  private:
+  ::proto::WebFeatures_Flag _internal_nodeletemessagetimelimit() const;
+  void _internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.WebFeatures)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int labelsdisplay_;
+    int voipindividualoutgoing_;
+    int groupsv3_;
+    int groupsv3create_;
+    int changenumberv2_;
+    int querystatusv3thumbnail_;
+    int livelocations_;
+    int queryvname_;
+    int voipindividualincoming_;
+    int quickrepliesquery_;
+    int payments_;
+    int stickerpackquery_;
+    int livelocationsfinal_;
+    int labelsedit_;
+    int mediaupload_;
+    int mediauploadrichquickreplies_;
+    int vnamev2_;
+    int videoplaybackurl_;
+    int statusranking_;
+    int voipindividualvideo_;
+    int thirdpartystickers_;
+    int frequentlyforwardedsetting_;
+    int groupsv4joinpermission_;
+    int recentstickers_;
+    int catalog_;
+    int starredstickers_;
+    int voipgroupcall_;
+    int templatemessage_;
+    int templatemessageinteractivity_;
+    int ephemeralmessages_;
+    int e2enotificationsync_;
+    int recentstickersv2_;
+    int recentstickersv3_;
+    int usernotice_;
+    int support_;
+    int groupuiicleanup_;
+    int groupdogfoodinginternalonly_;
+    int settingssync_;
+    int archivev2_;
+    int ephemeralallowgroupmembers_;
+    int ephemeral24hduration_;
+    int mdforceupgrade_;
+    int disappearingmode_;
+    int externalmdoptinavailable_;
+    int nodeletemessagetimelimit_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WebMessageInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebMessageInfo) */ {
+ public:
+  inline WebMessageInfo() : WebMessageInfo(nullptr) {}
+  ~WebMessageInfo() override;
+  explicit PROTOBUF_CONSTEXPR WebMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WebMessageInfo(const WebMessageInfo& from);
+  WebMessageInfo(WebMessageInfo&& from) noexcept
+    : WebMessageInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline WebMessageInfo& operator=(const WebMessageInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WebMessageInfo& operator=(WebMessageInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WebMessageInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WebMessageInfo* internal_default_instance() {
+    return reinterpret_cast<const WebMessageInfo*>(
+               &_WebMessageInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    222;
+
+  friend void swap(WebMessageInfo& a, WebMessageInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WebMessageInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WebMessageInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  WebMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<WebMessageInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WebMessageInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const WebMessageInfo& from) {
+    WebMessageInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WebMessageInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.WebMessageInfo";
+  }
+  protected:
+  explicit WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef WebMessageInfo_BizPrivacyStatus BizPrivacyStatus;
+  static constexpr BizPrivacyStatus E2EE =
+    WebMessageInfo_BizPrivacyStatus_E2EE;
+  static constexpr BizPrivacyStatus FB =
+    WebMessageInfo_BizPrivacyStatus_FB;
+  static constexpr BizPrivacyStatus BSP =
+    WebMessageInfo_BizPrivacyStatus_BSP;
+  static constexpr BizPrivacyStatus BSP_AND_FB =
+    WebMessageInfo_BizPrivacyStatus_BSP_AND_FB;
+  static inline bool BizPrivacyStatus_IsValid(int value) {
+    return WebMessageInfo_BizPrivacyStatus_IsValid(value);
+  }
+  static constexpr BizPrivacyStatus BizPrivacyStatus_MIN =
+    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN;
+  static constexpr BizPrivacyStatus BizPrivacyStatus_MAX =
+    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX;
+  static constexpr int BizPrivacyStatus_ARRAYSIZE =
+    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  BizPrivacyStatus_descriptor() {
+    return WebMessageInfo_BizPrivacyStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& BizPrivacyStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, BizPrivacyStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function BizPrivacyStatus_Name.");
+    return WebMessageInfo_BizPrivacyStatus_Name(enum_t_value);
+  }
+  static inline bool BizPrivacyStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      BizPrivacyStatus* value) {
+    return WebMessageInfo_BizPrivacyStatus_Parse(name, value);
+  }
+
+  typedef WebMessageInfo_Status Status;
+  static constexpr Status ERROR =
+    WebMessageInfo_Status_ERROR;
+  static constexpr Status PENDING =
+    WebMessageInfo_Status_PENDING;
+  static constexpr Status SERVER_ACK =
+    WebMessageInfo_Status_SERVER_ACK;
+  static constexpr Status DELIVERY_ACK =
+    WebMessageInfo_Status_DELIVERY_ACK;
+  static constexpr Status READ =
+    WebMessageInfo_Status_READ;
+  static constexpr Status PLAYED =
+    WebMessageInfo_Status_PLAYED;
+  static inline bool Status_IsValid(int value) {
+    return WebMessageInfo_Status_IsValid(value);
+  }
+  static constexpr Status Status_MIN =
+    WebMessageInfo_Status_Status_MIN;
+  static constexpr Status Status_MAX =
+    WebMessageInfo_Status_Status_MAX;
+  static constexpr int Status_ARRAYSIZE =
+    WebMessageInfo_Status_Status_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Status_descriptor() {
+    return WebMessageInfo_Status_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Status_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Status>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Status_Name.");
+    return WebMessageInfo_Status_Name(enum_t_value);
+  }
+  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Status* value) {
+    return WebMessageInfo_Status_Parse(name, value);
+  }
+
+  typedef WebMessageInfo_StubType StubType;
+  static constexpr StubType UNKNOWN =
+    WebMessageInfo_StubType_UNKNOWN;
+  static constexpr StubType REVOKE =
+    WebMessageInfo_StubType_REVOKE;
+  static constexpr StubType CIPHERTEXT =
+    WebMessageInfo_StubType_CIPHERTEXT;
+  static constexpr StubType FUTUREPROOF =
+    WebMessageInfo_StubType_FUTUREPROOF;
+  static constexpr StubType NON_VERIFIED_TRANSITION =
+    WebMessageInfo_StubType_NON_VERIFIED_TRANSITION;
+  static constexpr StubType UNVERIFIED_TRANSITION =
+    WebMessageInfo_StubType_UNVERIFIED_TRANSITION;
+  static constexpr StubType VERIFIED_TRANSITION =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION;
+  static constexpr StubType VERIFIED_LOW_UNKNOWN =
+    WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN;
+  static constexpr StubType VERIFIED_HIGH =
+    WebMessageInfo_StubType_VERIFIED_HIGH;
+  static constexpr StubType VERIFIED_INITIAL_UNKNOWN =
+    WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN;
+  static constexpr StubType VERIFIED_INITIAL_LOW =
+    WebMessageInfo_StubType_VERIFIED_INITIAL_LOW;
+  static constexpr StubType VERIFIED_INITIAL_HIGH =
+    WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH;
+  static constexpr StubType VERIFIED_TRANSITION_ANY_TO_NONE =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE;
+  static constexpr StubType VERIFIED_TRANSITION_ANY_TO_HIGH =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH;
+  static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_LOW =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW;
+  static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_UNKNOWN =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN;
+  static constexpr StubType VERIFIED_TRANSITION_UNKNOWN_TO_LOW =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW;
+  static constexpr StubType VERIFIED_TRANSITION_LOW_TO_UNKNOWN =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN;
+  static constexpr StubType VERIFIED_TRANSITION_NONE_TO_LOW =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW;
+  static constexpr StubType VERIFIED_TRANSITION_NONE_TO_UNKNOWN =
+    WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN;
+  static constexpr StubType GROUP_CREATE =
+    WebMessageInfo_StubType_GROUP_CREATE;
+  static constexpr StubType GROUP_CHANGE_SUBJECT =
+    WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT;
+  static constexpr StubType GROUP_CHANGE_ICON =
+    WebMessageInfo_StubType_GROUP_CHANGE_ICON;
+  static constexpr StubType GROUP_CHANGE_INVITE_LINK =
+    WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK;
+  static constexpr StubType GROUP_CHANGE_DESCRIPTION =
+    WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION;
+  static constexpr StubType GROUP_CHANGE_RESTRICT =
+    WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT;
+  static constexpr StubType GROUP_CHANGE_ANNOUNCE =
+    WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE;
+  static constexpr StubType GROUP_PARTICIPANT_ADD =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD;
+  static constexpr StubType GROUP_PARTICIPANT_REMOVE =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE;
+  static constexpr StubType GROUP_PARTICIPANT_PROMOTE =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE;
+  static constexpr StubType GROUP_PARTICIPANT_DEMOTE =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE;
+  static constexpr StubType GROUP_PARTICIPANT_INVITE =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE;
+  static constexpr StubType GROUP_PARTICIPANT_LEAVE =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE;
+  static constexpr StubType GROUP_PARTICIPANT_CHANGE_NUMBER =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER;
+  static constexpr StubType BROADCAST_CREATE =
+    WebMessageInfo_StubType_BROADCAST_CREATE;
+  static constexpr StubType BROADCAST_ADD =
+    WebMessageInfo_StubType_BROADCAST_ADD;
+  static constexpr StubType BROADCAST_REMOVE =
+    WebMessageInfo_StubType_BROADCAST_REMOVE;
+  static constexpr StubType GENERIC_NOTIFICATION =
+    WebMessageInfo_StubType_GENERIC_NOTIFICATION;
+  static constexpr StubType E2E_IDENTITY_CHANGED =
+    WebMessageInfo_StubType_E2E_IDENTITY_CHANGED;
+  static constexpr StubType E2E_ENCRYPTED =
+    WebMessageInfo_StubType_E2E_ENCRYPTED;
+  static constexpr StubType CALL_MISSED_VOICE =
+    WebMessageInfo_StubType_CALL_MISSED_VOICE;
+  static constexpr StubType CALL_MISSED_VIDEO =
+    WebMessageInfo_StubType_CALL_MISSED_VIDEO;
+  static constexpr StubType INDIVIDUAL_CHANGE_NUMBER =
+    WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER;
+  static constexpr StubType GROUP_DELETE =
+    WebMessageInfo_StubType_GROUP_DELETE;
+  static constexpr StubType GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE =
+    WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE;
+  static constexpr StubType CALL_MISSED_GROUP_VOICE =
+    WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE;
+  static constexpr StubType CALL_MISSED_GROUP_VIDEO =
+    WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO;
+  static constexpr StubType PAYMENT_CIPHERTEXT =
+    WebMessageInfo_StubType_PAYMENT_CIPHERTEXT;
+  static constexpr StubType PAYMENT_FUTUREPROOF =
+    WebMessageInfo_StubType_PAYMENT_FUTUREPROOF;
+  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED =
+    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED;
+  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED =
+    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED;
+  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED =
+    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED;
+  static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP =
+    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP;
+  static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP =
+    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP;
+  static constexpr StubType PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER =
+    WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER;
+  static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_REMINDER =
+    WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER;
+  static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_INVITATION =
+    WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION;
+  static constexpr StubType PAYMENT_ACTION_REQUEST_DECLINED =
+    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED;
+  static constexpr StubType PAYMENT_ACTION_REQUEST_EXPIRED =
+    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED;
+  static constexpr StubType PAYMENT_ACTION_REQUEST_CANCELLED =
+    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED;
+  static constexpr StubType BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM =
+    WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM;
+  static constexpr StubType BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP =
+    WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP;
+  static constexpr StubType BIZ_INTRO_TOP =
+    WebMessageInfo_StubType_BIZ_INTRO_TOP;
+  static constexpr StubType BIZ_INTRO_BOTTOM =
+    WebMessageInfo_StubType_BIZ_INTRO_BOTTOM;
+  static constexpr StubType BIZ_NAME_CHANGE =
+    WebMessageInfo_StubType_BIZ_NAME_CHANGE;
+  static constexpr StubType BIZ_MOVE_TO_CONSUMER_APP =
+    WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP;
+  static constexpr StubType BIZ_TWO_TIER_MIGRATION_TOP =
+    WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP;
+  static constexpr StubType BIZ_TWO_TIER_MIGRATION_BOTTOM =
+    WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM;
+  static constexpr StubType OVERSIZED =
+    WebMessageInfo_StubType_OVERSIZED;
+  static constexpr StubType GROUP_CHANGE_NO_FREQUENTLY_FORWARDED =
+    WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED;
+  static constexpr StubType GROUP_V4_ADD_INVITE_SENT =
+    WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT;
+  static constexpr StubType GROUP_PARTICIPANT_ADD_REQUEST_JOIN =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN;
+  static constexpr StubType CHANGE_EPHEMERAL_SETTING =
+    WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING;
+  static constexpr StubType E2E_DEVICE_CHANGED =
+    WebMessageInfo_StubType_E2E_DEVICE_CHANGED;
+  static constexpr StubType VIEWED_ONCE =
+    WebMessageInfo_StubType_VIEWED_ONCE;
+  static constexpr StubType E2E_ENCRYPTED_NOW =
+    WebMessageInfo_StubType_E2E_ENCRYPTED_NOW;
+  static constexpr StubType BLUE_MSG_BSP_FB_TO_BSP_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE;
+  static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_FB =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB;
+  static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE;
+  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE;
+  static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_TO_BSP_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE;
+  static constexpr StubType BLUE_MSG_SELF_FB_TO_SELF_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE;
+  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE;
+  static constexpr StubType BLUE_MSG_SELF_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_TO_BSP_FB =
+    WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB;
+  static constexpr StubType BLUE_MSG_TO_CONSUMER =
+    WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER;
+  static constexpr StubType BLUE_MSG_TO_SELF_FB =
+    WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB;
+  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED;
+  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED;
+  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED;
+  static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_VERIFIED_TO_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
+  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
+    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
+  static constexpr StubType E2E_IDENTITY_UNAVAILABLE =
+    WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE;
+  static constexpr StubType GROUP_CREATING =
+    WebMessageInfo_StubType_GROUP_CREATING;
+  static constexpr StubType GROUP_CREATE_FAILED =
+    WebMessageInfo_StubType_GROUP_CREATE_FAILED;
+  static constexpr StubType GROUP_BOUNCED =
+    WebMessageInfo_StubType_GROUP_BOUNCED;
+  static constexpr StubType BLOCK_CONTACT =
+    WebMessageInfo_StubType_BLOCK_CONTACT;
+  static constexpr StubType EPHEMERAL_SETTING_NOT_APPLIED =
+    WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED;
+  static constexpr StubType SYNC_FAILED =
+    WebMessageInfo_StubType_SYNC_FAILED;
+  static constexpr StubType SYNCING =
+    WebMessageInfo_StubType_SYNCING;
+  static constexpr StubType BIZ_PRIVACY_MODE_INIT_FB =
+    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB;
+  static constexpr StubType BIZ_PRIVACY_MODE_INIT_BSP =
+    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP;
+  static constexpr StubType BIZ_PRIVACY_MODE_TO_FB =
+    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB;
+  static constexpr StubType BIZ_PRIVACY_MODE_TO_BSP =
+    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP;
+  static constexpr StubType DISAPPEARING_MODE =
+    WebMessageInfo_StubType_DISAPPEARING_MODE;
+  static constexpr StubType E2E_DEVICE_FETCH_FAILED =
+    WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED;
+  static constexpr StubType ADMIN_REVOKE =
+    WebMessageInfo_StubType_ADMIN_REVOKE;
+  static constexpr StubType GROUP_INVITE_LINK_GROWTH_LOCKED =
+    WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED;
+  static constexpr StubType COMMUNITY_LINK_PARENT_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP;
+  static constexpr StubType COMMUNITY_LINK_SIBLING_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP;
+  static constexpr StubType COMMUNITY_LINK_SUB_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP;
+  static constexpr StubType COMMUNITY_UNLINK_PARENT_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP;
+  static constexpr StubType COMMUNITY_UNLINK_SIBLING_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP;
+  static constexpr StubType COMMUNITY_UNLINK_SUB_GROUP =
+    WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP;
+  static constexpr StubType GROUP_PARTICIPANT_ACCEPT =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT;
+  static constexpr StubType GROUP_PARTICIPANT_LINKED_GROUP_JOIN =
+    WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN;
+  static constexpr StubType COMMUNITY_CREATE =
+    WebMessageInfo_StubType_COMMUNITY_CREATE;
+  static constexpr StubType EPHEMERAL_KEEP_IN_CHAT =
+    WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT;
+  static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST =
+    WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST;
+  static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE =
+    WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE;
+  static constexpr StubType INTEGRITY_UNLINK_PARENT_GROUP =
+    WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP;
+  static constexpr StubType COMMUNITY_PARTICIPANT_PROMOTE =
+    WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE;
+  static constexpr StubType COMMUNITY_PARTICIPANT_DEMOTE =
+    WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE;
+  static constexpr StubType COMMUNITY_PARENT_GROUP_DELETED =
+    WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED;
+  static inline bool StubType_IsValid(int value) {
+    return WebMessageInfo_StubType_IsValid(value);
+  }
+  static constexpr StubType StubType_MIN =
+    WebMessageInfo_StubType_StubType_MIN;
+  static constexpr StubType StubType_MAX =
+    WebMessageInfo_StubType_StubType_MAX;
+  static constexpr int StubType_ARRAYSIZE =
+    WebMessageInfo_StubType_StubType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  StubType_descriptor() {
+    return WebMessageInfo_StubType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& StubType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, StubType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function StubType_Name.");
+    return WebMessageInfo_StubType_Name(enum_t_value);
+  }
+  static inline bool StubType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      StubType* value) {
+    return WebMessageInfo_StubType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageStubParametersFieldNumber = 26,
+    kLabelsFieldNumber = 28,
+    kUserReceiptFieldNumber = 40,
+    kReactionsFieldNumber = 41,
+    kPollUpdatesFieldNumber = 45,
+    kParticipantFieldNumber = 5,
+    kPushNameFieldNumber = 19,
+    kMediaCiphertextSha256FieldNumber = 20,
+    kVerifiedBizNameFieldNumber = 37,
+    kFutureproofDataFieldNumber = 43,
+    kAgentIdFieldNumber = 47,
+    kMessageSecretFieldNumber = 49,
+    kOriginalSelfAuthorUserJidStringFieldNumber = 51,
+    kKeyFieldNumber = 1,
+    kMessageFieldNumber = 2,
+    kPaymentInfoFieldNumber = 29,
+    kFinalLiveLocationFieldNumber = 30,
+    kQuotedPaymentInfoFieldNumber = 31,
+    kMediaDataFieldNumber = 38,
+    kPhotoChangeFieldNumber = 39,
+    kQuotedStickerDataFieldNumber = 42,
+    kStatusPsaFieldNumber = 44,
+    kPollAdditionalMetadataFieldNumber = 46,
+    kKeepInChatFieldNumber = 50,
+    kMessageTimestampFieldNumber = 3,
+    kMessageC2STimestampFieldNumber = 6,
+    kStatusFieldNumber = 4,
+    kIgnoreFieldNumber = 16,
+    kStarredFieldNumber = 17,
+    kBroadcastFieldNumber = 18,
+    kMulticastFieldNumber = 21,
+    kMessageStubTypeFieldNumber = 24,
+    kUrlTextFieldNumber = 22,
+    kUrlNumberFieldNumber = 23,
+    kClearMediaFieldNumber = 25,
+    kEphemeralOffToOnFieldNumber = 34,
+    kDurationFieldNumber = 27,
+    kEphemeralDurationFieldNumber = 33,
+    kEphemeralStartTimestampFieldNumber = 32,
+    kBizPrivacyStatusFieldNumber = 36,
+    kEphemeralOutOfSyncFieldNumber = 35,
+    kStatusAlreadyViewedFieldNumber = 48,
+    kRevokeMessageTimestampFieldNumber = 52,
+  };
+  // repeated string messageStubParameters = 26;
+  int messagestubparameters_size() const;
+  private:
+  int _internal_messagestubparameters_size() const;
+  public:
+  void clear_messagestubparameters();
+  const std::string& messagestubparameters(int index) const;
+  std::string* mutable_messagestubparameters(int index);
+  void set_messagestubparameters(int index, const std::string& value);
+  void set_messagestubparameters(int index, std::string&& value);
+  void set_messagestubparameters(int index, const char* value);
+  void set_messagestubparameters(int index, const char* value, size_t size);
+  std::string* add_messagestubparameters();
+  void add_messagestubparameters(const std::string& value);
+  void add_messagestubparameters(std::string&& value);
+  void add_messagestubparameters(const char* value);
+  void add_messagestubparameters(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& messagestubparameters() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_messagestubparameters();
+  private:
+  const std::string& _internal_messagestubparameters(int index) const;
+  std::string* _internal_add_messagestubparameters();
+  public:
+
+  // repeated string labels = 28;
+  int labels_size() const;
+  private:
+  int _internal_labels_size() const;
+  public:
+  void clear_labels();
+  const std::string& labels(int index) const;
+  std::string* mutable_labels(int index);
+  void set_labels(int index, const std::string& value);
+  void set_labels(int index, std::string&& value);
+  void set_labels(int index, const char* value);
+  void set_labels(int index, const char* value, size_t size);
+  std::string* add_labels();
+  void add_labels(const std::string& value);
+  void add_labels(std::string&& value);
+  void add_labels(const char* value);
+  void add_labels(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& labels() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_labels();
+  private:
+  const std::string& _internal_labels(int index) const;
+  std::string* _internal_add_labels();
+  public:
+
+  // repeated .proto.UserReceipt userReceipt = 40;
+  int userreceipt_size() const;
+  private:
+  int _internal_userreceipt_size() const;
+  public:
+  void clear_userreceipt();
+  ::proto::UserReceipt* mutable_userreceipt(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >*
+      mutable_userreceipt();
+  private:
+  const ::proto::UserReceipt& _internal_userreceipt(int index) const;
+  ::proto::UserReceipt* _internal_add_userreceipt();
+  public:
+  const ::proto::UserReceipt& userreceipt(int index) const;
+  ::proto::UserReceipt* add_userreceipt();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >&
+      userreceipt() const;
+
+  // repeated .proto.Reaction reactions = 41;
+  int reactions_size() const;
+  private:
+  int _internal_reactions_size() const;
+  public:
+  void clear_reactions();
+  ::proto::Reaction* mutable_reactions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >*
+      mutable_reactions();
+  private:
+  const ::proto::Reaction& _internal_reactions(int index) const;
+  ::proto::Reaction* _internal_add_reactions();
+  public:
+  const ::proto::Reaction& reactions(int index) const;
+  ::proto::Reaction* add_reactions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >&
+      reactions() const;
+
+  // repeated .proto.PollUpdate pollUpdates = 45;
+  int pollupdates_size() const;
+  private:
+  int _internal_pollupdates_size() const;
+  public:
+  void clear_pollupdates();
+  ::proto::PollUpdate* mutable_pollupdates(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >*
+      mutable_pollupdates();
+  private:
+  const ::proto::PollUpdate& _internal_pollupdates(int index) const;
+  ::proto::PollUpdate* _internal_add_pollupdates();
+  public:
+  const ::proto::PollUpdate& pollupdates(int index) const;
+  ::proto::PollUpdate* add_pollupdates();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >&
+      pollupdates() const;
+
+  // optional string participant = 5;
+  bool has_participant() const;
+  private:
+  bool _internal_has_participant() const;
+  public:
+  void clear_participant();
+  const std::string& participant() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_participant(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_participant();
+  PROTOBUF_NODISCARD std::string* release_participant();
+  void set_allocated_participant(std::string* participant);
+  private:
+  const std::string& _internal_participant() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
+  std::string* _internal_mutable_participant();
+  public:
+
+  // optional string pushName = 19;
+  bool has_pushname() const;
+  private:
+  bool _internal_has_pushname() const;
+  public:
+  void clear_pushname();
+  const std::string& pushname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_pushname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_pushname();
+  PROTOBUF_NODISCARD std::string* release_pushname();
+  void set_allocated_pushname(std::string* pushname);
+  private:
+  const std::string& _internal_pushname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
+  std::string* _internal_mutable_pushname();
+  public:
+
+  // optional bytes mediaCiphertextSha256 = 20;
+  bool has_mediaciphertextsha256() const;
+  private:
+  bool _internal_has_mediaciphertextsha256() const;
+  public:
+  void clear_mediaciphertextsha256();
+  const std::string& mediaciphertextsha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mediaciphertextsha256();
+  PROTOBUF_NODISCARD std::string* release_mediaciphertextsha256();
+  void set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256);
+  private:
+  const std::string& _internal_mediaciphertextsha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaciphertextsha256(const std::string& value);
+  std::string* _internal_mutable_mediaciphertextsha256();
+  public:
+
+  // optional string verifiedBizName = 37;
+  bool has_verifiedbizname() const;
+  private:
+  bool _internal_has_verifiedbizname() const;
+  public:
+  void clear_verifiedbizname();
+  const std::string& verifiedbizname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_verifiedbizname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_verifiedbizname();
+  PROTOBUF_NODISCARD std::string* release_verifiedbizname();
+  void set_allocated_verifiedbizname(std::string* verifiedbizname);
+  private:
+  const std::string& _internal_verifiedbizname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedbizname(const std::string& value);
+  std::string* _internal_mutable_verifiedbizname();
+  public:
+
+  // optional bytes futureproofData = 43;
+  bool has_futureproofdata() const;
+  private:
+  bool _internal_has_futureproofdata() const;
+  public:
+  void clear_futureproofdata();
+  const std::string& futureproofdata() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_futureproofdata(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_futureproofdata();
+  PROTOBUF_NODISCARD std::string* release_futureproofdata();
+  void set_allocated_futureproofdata(std::string* futureproofdata);
+  private:
+  const std::string& _internal_futureproofdata() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofdata(const std::string& value);
+  std::string* _internal_mutable_futureproofdata();
+  public:
+
+  // optional string agentId = 47;
+  bool has_agentid() const;
+  private:
+  bool _internal_has_agentid() const;
+  public:
+  void clear_agentid();
+  const std::string& agentid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_agentid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_agentid();
+  PROTOBUF_NODISCARD std::string* release_agentid();
+  void set_allocated_agentid(std::string* agentid);
+  private:
+  const std::string& _internal_agentid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_agentid(const std::string& value);
+  std::string* _internal_mutable_agentid();
+  public:
+
+  // optional bytes messageSecret = 49;
+  bool has_messagesecret() const;
+  private:
+  bool _internal_has_messagesecret() const;
+  public:
+  void clear_messagesecret();
+  const std::string& messagesecret() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_messagesecret(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_messagesecret();
+  PROTOBUF_NODISCARD std::string* release_messagesecret();
+  void set_allocated_messagesecret(std::string* messagesecret);
+  private:
+  const std::string& _internal_messagesecret() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
+  std::string* _internal_mutable_messagesecret();
+  public:
+
+  // optional string originalSelfAuthorUserJidString = 51;
+  bool has_originalselfauthoruserjidstring() const;
+  private:
+  bool _internal_has_originalselfauthoruserjidstring() const;
+  public:
+  void clear_originalselfauthoruserjidstring();
+  const std::string& originalselfauthoruserjidstring() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_originalselfauthoruserjidstring();
+  PROTOBUF_NODISCARD std::string* release_originalselfauthoruserjidstring();
+  void set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring);
+  private:
+  const std::string& _internal_originalselfauthoruserjidstring() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalselfauthoruserjidstring(const std::string& value);
+  std::string* _internal_mutable_originalselfauthoruserjidstring();
+  public:
+
+  // required .proto.MessageKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::proto::MessageKey& key() const;
+  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
+  ::proto::MessageKey* mutable_key();
+  void set_allocated_key(::proto::MessageKey* key);
+  private:
+  const ::proto::MessageKey& _internal_key() const;
+  ::proto::MessageKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::proto::MessageKey* key);
+  ::proto::MessageKey* unsafe_arena_release_key();
+
+  // optional .proto.Message message = 2;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const ::proto::Message& message() const;
+  PROTOBUF_NODISCARD ::proto::Message* release_message();
+  ::proto::Message* mutable_message();
+  void set_allocated_message(::proto::Message* message);
+  private:
+  const ::proto::Message& _internal_message() const;
+  ::proto::Message* _internal_mutable_message();
+  public:
+  void unsafe_arena_set_allocated_message(
+      ::proto::Message* message);
+  ::proto::Message* unsafe_arena_release_message();
+
+  // optional .proto.PaymentInfo paymentInfo = 29;
+  bool has_paymentinfo() const;
+  private:
+  bool _internal_has_paymentinfo() const;
+  public:
+  void clear_paymentinfo();
+  const ::proto::PaymentInfo& paymentinfo() const;
+  PROTOBUF_NODISCARD ::proto::PaymentInfo* release_paymentinfo();
+  ::proto::PaymentInfo* mutable_paymentinfo();
+  void set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo);
+  private:
+  const ::proto::PaymentInfo& _internal_paymentinfo() const;
+  ::proto::PaymentInfo* _internal_mutable_paymentinfo();
+  public:
+  void unsafe_arena_set_allocated_paymentinfo(
+      ::proto::PaymentInfo* paymentinfo);
+  ::proto::PaymentInfo* unsafe_arena_release_paymentinfo();
+
+  // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
+  bool has_finallivelocation() const;
+  private:
+  bool _internal_has_finallivelocation() const;
+  public:
+  void clear_finallivelocation();
+  const ::proto::Message_LiveLocationMessage& finallivelocation() const;
+  PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_finallivelocation();
+  ::proto::Message_LiveLocationMessage* mutable_finallivelocation();
+  void set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation);
+  private:
+  const ::proto::Message_LiveLocationMessage& _internal_finallivelocation() const;
+  ::proto::Message_LiveLocationMessage* _internal_mutable_finallivelocation();
+  public:
+  void unsafe_arena_set_allocated_finallivelocation(
+      ::proto::Message_LiveLocationMessage* finallivelocation);
+  ::proto::Message_LiveLocationMessage* unsafe_arena_release_finallivelocation();
+
+  // optional .proto.PaymentInfo quotedPaymentInfo = 31;
+  bool has_quotedpaymentinfo() const;
+  private:
+  bool _internal_has_quotedpaymentinfo() const;
+  public:
+  void clear_quotedpaymentinfo();
+  const ::proto::PaymentInfo& quotedpaymentinfo() const;
+  PROTOBUF_NODISCARD ::proto::PaymentInfo* release_quotedpaymentinfo();
+  ::proto::PaymentInfo* mutable_quotedpaymentinfo();
+  void set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo);
+  private:
+  const ::proto::PaymentInfo& _internal_quotedpaymentinfo() const;
+  ::proto::PaymentInfo* _internal_mutable_quotedpaymentinfo();
+  public:
+  void unsafe_arena_set_allocated_quotedpaymentinfo(
+      ::proto::PaymentInfo* quotedpaymentinfo);
+  ::proto::PaymentInfo* unsafe_arena_release_quotedpaymentinfo();
+
+  // optional .proto.MediaData mediaData = 38;
+  bool has_mediadata() const;
+  private:
+  bool _internal_has_mediadata() const;
+  public:
+  void clear_mediadata();
+  const ::proto::MediaData& mediadata() const;
+  PROTOBUF_NODISCARD ::proto::MediaData* release_mediadata();
+  ::proto::MediaData* mutable_mediadata();
+  void set_allocated_mediadata(::proto::MediaData* mediadata);
+  private:
+  const ::proto::MediaData& _internal_mediadata() const;
+  ::proto::MediaData* _internal_mutable_mediadata();
+  public:
+  void unsafe_arena_set_allocated_mediadata(
+      ::proto::MediaData* mediadata);
+  ::proto::MediaData* unsafe_arena_release_mediadata();
+
+  // optional .proto.PhotoChange photoChange = 39;
+  bool has_photochange() const;
+  private:
+  bool _internal_has_photochange() const;
+  public:
+  void clear_photochange();
+  const ::proto::PhotoChange& photochange() const;
+  PROTOBUF_NODISCARD ::proto::PhotoChange* release_photochange();
+  ::proto::PhotoChange* mutable_photochange();
+  void set_allocated_photochange(::proto::PhotoChange* photochange);
+  private:
+  const ::proto::PhotoChange& _internal_photochange() const;
+  ::proto::PhotoChange* _internal_mutable_photochange();
+  public:
+  void unsafe_arena_set_allocated_photochange(
+      ::proto::PhotoChange* photochange);
+  ::proto::PhotoChange* unsafe_arena_release_photochange();
+
+  // optional .proto.MediaData quotedStickerData = 42;
+  bool has_quotedstickerdata() const;
+  private:
+  bool _internal_has_quotedstickerdata() const;
+  public:
+  void clear_quotedstickerdata();
+  const ::proto::MediaData& quotedstickerdata() const;
+  PROTOBUF_NODISCARD ::proto::MediaData* release_quotedstickerdata();
+  ::proto::MediaData* mutable_quotedstickerdata();
+  void set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata);
+  private:
+  const ::proto::MediaData& _internal_quotedstickerdata() const;
+  ::proto::MediaData* _internal_mutable_quotedstickerdata();
+  public:
+  void unsafe_arena_set_allocated_quotedstickerdata(
+      ::proto::MediaData* quotedstickerdata);
+  ::proto::MediaData* unsafe_arena_release_quotedstickerdata();
+
+  // optional .proto.StatusPSA statusPsa = 44;
+  bool has_statuspsa() const;
+  private:
+  bool _internal_has_statuspsa() const;
+  public:
+  void clear_statuspsa();
+  const ::proto::StatusPSA& statuspsa() const;
+  PROTOBUF_NODISCARD ::proto::StatusPSA* release_statuspsa();
+  ::proto::StatusPSA* mutable_statuspsa();
+  void set_allocated_statuspsa(::proto::StatusPSA* statuspsa);
+  private:
+  const ::proto::StatusPSA& _internal_statuspsa() const;
+  ::proto::StatusPSA* _internal_mutable_statuspsa();
+  public:
+  void unsafe_arena_set_allocated_statuspsa(
+      ::proto::StatusPSA* statuspsa);
+  ::proto::StatusPSA* unsafe_arena_release_statuspsa();
+
+  // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
+  bool has_polladditionalmetadata() const;
+  private:
+  bool _internal_has_polladditionalmetadata() const;
+  public:
+  void clear_polladditionalmetadata();
+  const ::proto::PollAdditionalMetadata& polladditionalmetadata() const;
+  PROTOBUF_NODISCARD ::proto::PollAdditionalMetadata* release_polladditionalmetadata();
+  ::proto::PollAdditionalMetadata* mutable_polladditionalmetadata();
+  void set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata);
+  private:
+  const ::proto::PollAdditionalMetadata& _internal_polladditionalmetadata() const;
+  ::proto::PollAdditionalMetadata* _internal_mutable_polladditionalmetadata();
+  public:
+  void unsafe_arena_set_allocated_polladditionalmetadata(
+      ::proto::PollAdditionalMetadata* polladditionalmetadata);
+  ::proto::PollAdditionalMetadata* unsafe_arena_release_polladditionalmetadata();
+
+  // optional .proto.KeepInChat keepInChat = 50;
+  bool has_keepinchat() const;
+  private:
+  bool _internal_has_keepinchat() const;
+  public:
+  void clear_keepinchat();
+  const ::proto::KeepInChat& keepinchat() const;
+  PROTOBUF_NODISCARD ::proto::KeepInChat* release_keepinchat();
+  ::proto::KeepInChat* mutable_keepinchat();
+  void set_allocated_keepinchat(::proto::KeepInChat* keepinchat);
+  private:
+  const ::proto::KeepInChat& _internal_keepinchat() const;
+  ::proto::KeepInChat* _internal_mutable_keepinchat();
+  public:
+  void unsafe_arena_set_allocated_keepinchat(
+      ::proto::KeepInChat* keepinchat);
+  ::proto::KeepInChat* unsafe_arena_release_keepinchat();
+
+  // optional uint64 messageTimestamp = 3;
+  bool has_messagetimestamp() const;
+  private:
+  bool _internal_has_messagetimestamp() const;
+  public:
+  void clear_messagetimestamp();
+  uint64_t messagetimestamp() const;
+  void set_messagetimestamp(uint64_t value);
+  private:
+  uint64_t _internal_messagetimestamp() const;
+  void _internal_set_messagetimestamp(uint64_t value);
+  public:
+
+  // optional uint64 messageC2STimestamp = 6;
+  bool has_messagec2stimestamp() const;
+  private:
+  bool _internal_has_messagec2stimestamp() const;
+  public:
+  void clear_messagec2stimestamp();
+  uint64_t messagec2stimestamp() const;
+  void set_messagec2stimestamp(uint64_t value);
+  private:
+  uint64_t _internal_messagec2stimestamp() const;
+  void _internal_set_messagec2stimestamp(uint64_t value);
+  public:
+
+  // optional .proto.WebMessageInfo.Status status = 4;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::proto::WebMessageInfo_Status status() const;
+  void set_status(::proto::WebMessageInfo_Status value);
+  private:
+  ::proto::WebMessageInfo_Status _internal_status() const;
+  void _internal_set_status(::proto::WebMessageInfo_Status value);
+  public:
+
+  // optional bool ignore = 16;
+  bool has_ignore() const;
+  private:
+  bool _internal_has_ignore() const;
+  public:
+  void clear_ignore();
+  bool ignore() const;
+  void set_ignore(bool value);
+  private:
+  bool _internal_ignore() const;
+  void _internal_set_ignore(bool value);
+  public:
+
+  // optional bool starred = 17;
+  bool has_starred() const;
+  private:
+  bool _internal_has_starred() const;
+  public:
+  void clear_starred();
+  bool starred() const;
+  void set_starred(bool value);
+  private:
+  bool _internal_starred() const;
+  void _internal_set_starred(bool value);
+  public:
+
+  // optional bool broadcast = 18;
+  bool has_broadcast() const;
+  private:
+  bool _internal_has_broadcast() const;
+  public:
+  void clear_broadcast();
+  bool broadcast() const;
+  void set_broadcast(bool value);
+  private:
+  bool _internal_broadcast() const;
+  void _internal_set_broadcast(bool value);
+  public:
+
+  // optional bool multicast = 21;
+  bool has_multicast() const;
+  private:
+  bool _internal_has_multicast() const;
+  public:
+  void clear_multicast();
+  bool multicast() const;
+  void set_multicast(bool value);
+  private:
+  bool _internal_multicast() const;
+  void _internal_set_multicast(bool value);
+  public:
+
+  // optional .proto.WebMessageInfo.StubType messageStubType = 24;
+  bool has_messagestubtype() const;
+  private:
+  bool _internal_has_messagestubtype() const;
+  public:
+  void clear_messagestubtype();
+  ::proto::WebMessageInfo_StubType messagestubtype() const;
+  void set_messagestubtype(::proto::WebMessageInfo_StubType value);
+  private:
+  ::proto::WebMessageInfo_StubType _internal_messagestubtype() const;
+  void _internal_set_messagestubtype(::proto::WebMessageInfo_StubType value);
+  public:
+
+  // optional bool urlText = 22;
+  bool has_urltext() const;
+  private:
+  bool _internal_has_urltext() const;
+  public:
+  void clear_urltext();
+  bool urltext() const;
+  void set_urltext(bool value);
+  private:
+  bool _internal_urltext() const;
+  void _internal_set_urltext(bool value);
+  public:
+
+  // optional bool urlNumber = 23;
+  bool has_urlnumber() const;
+  private:
+  bool _internal_has_urlnumber() const;
+  public:
+  void clear_urlnumber();
+  bool urlnumber() const;
+  void set_urlnumber(bool value);
+  private:
+  bool _internal_urlnumber() const;
+  void _internal_set_urlnumber(bool value);
+  public:
+
+  // optional bool clearMedia = 25;
+  bool has_clearmedia() const;
+  private:
+  bool _internal_has_clearmedia() const;
+  public:
+  void clear_clearmedia();
+  bool clearmedia() const;
+  void set_clearmedia(bool value);
+  private:
+  bool _internal_clearmedia() const;
+  void _internal_set_clearmedia(bool value);
+  public:
+
+  // optional bool ephemeralOffToOn = 34;
+  bool has_ephemeralofftoon() const;
+  private:
+  bool _internal_has_ephemeralofftoon() const;
+  public:
+  void clear_ephemeralofftoon();
+  bool ephemeralofftoon() const;
+  void set_ephemeralofftoon(bool value);
+  private:
+  bool _internal_ephemeralofftoon() const;
+  void _internal_set_ephemeralofftoon(bool value);
+  public:
+
+  // optional uint32 duration = 27;
+  bool has_duration() const;
+  private:
+  bool _internal_has_duration() const;
+  public:
+  void clear_duration();
+  uint32_t duration() const;
+  void set_duration(uint32_t value);
+  private:
+  uint32_t _internal_duration() const;
+  void _internal_set_duration(uint32_t value);
+  public:
+
+  // optional uint32 ephemeralDuration = 33;
+  bool has_ephemeralduration() const;
+  private:
+  bool _internal_has_ephemeralduration() const;
+  public:
+  void clear_ephemeralduration();
+  uint32_t ephemeralduration() const;
+  void set_ephemeralduration(uint32_t value);
+  private:
+  uint32_t _internal_ephemeralduration() const;
+  void _internal_set_ephemeralduration(uint32_t value);
+  public:
+
+  // optional uint64 ephemeralStartTimestamp = 32;
+  bool has_ephemeralstarttimestamp() const;
+  private:
+  bool _internal_has_ephemeralstarttimestamp() const;
+  public:
+  void clear_ephemeralstarttimestamp();
+  uint64_t ephemeralstarttimestamp() const;
+  void set_ephemeralstarttimestamp(uint64_t value);
+  private:
+  uint64_t _internal_ephemeralstarttimestamp() const;
+  void _internal_set_ephemeralstarttimestamp(uint64_t value);
+  public:
+
+  // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
+  bool has_bizprivacystatus() const;
+  private:
+  bool _internal_has_bizprivacystatus() const;
+  public:
+  void clear_bizprivacystatus();
+  ::proto::WebMessageInfo_BizPrivacyStatus bizprivacystatus() const;
+  void set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value);
+  private:
+  ::proto::WebMessageInfo_BizPrivacyStatus _internal_bizprivacystatus() const;
+  void _internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value);
+  public:
+
+  // optional bool ephemeralOutOfSync = 35;
+  bool has_ephemeraloutofsync() const;
+  private:
+  bool _internal_has_ephemeraloutofsync() const;
+  public:
+  void clear_ephemeraloutofsync();
+  bool ephemeraloutofsync() const;
+  void set_ephemeraloutofsync(bool value);
+  private:
+  bool _internal_ephemeraloutofsync() const;
+  void _internal_set_ephemeraloutofsync(bool value);
+  public:
+
+  // optional bool statusAlreadyViewed = 48;
+  bool has_statusalreadyviewed() const;
+  private:
+  bool _internal_has_statusalreadyviewed() const;
+  public:
+  void clear_statusalreadyviewed();
+  bool statusalreadyviewed() const;
+  void set_statusalreadyviewed(bool value);
+  private:
+  bool _internal_statusalreadyviewed() const;
+  void _internal_set_statusalreadyviewed(bool value);
+  public:
+
+  // optional uint64 revokeMessageTimestamp = 52;
+  bool has_revokemessagetimestamp() const;
+  private:
+  bool _internal_has_revokemessagetimestamp() const;
+  public:
+  void clear_revokemessagetimestamp();
+  uint64_t revokemessagetimestamp() const;
+  void set_revokemessagetimestamp(uint64_t value);
+  private:
+  uint64_t _internal_revokemessagetimestamp() const;
+  void _internal_set_revokemessagetimestamp(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.WebMessageInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> messagestubparameters_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> labels_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt > userreceipt_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction > reactions_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate > pollupdates_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaciphertextsha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedbizname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofdata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agentid_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalselfauthoruserjidstring_;
+    ::proto::MessageKey* key_;
+    ::proto::Message* message_;
+    ::proto::PaymentInfo* paymentinfo_;
+    ::proto::Message_LiveLocationMessage* finallivelocation_;
+    ::proto::PaymentInfo* quotedpaymentinfo_;
+    ::proto::MediaData* mediadata_;
+    ::proto::PhotoChange* photochange_;
+    ::proto::MediaData* quotedstickerdata_;
+    ::proto::StatusPSA* statuspsa_;
+    ::proto::PollAdditionalMetadata* polladditionalmetadata_;
+    ::proto::KeepInChat* keepinchat_;
+    uint64_t messagetimestamp_;
+    uint64_t messagec2stimestamp_;
+    int status_;
+    bool ignore_;
+    bool starred_;
+    bool broadcast_;
+    bool multicast_;
+    int messagestubtype_;
+    bool urltext_;
+    bool urlnumber_;
+    bool clearmedia_;
+    bool ephemeralofftoon_;
+    uint32_t duration_;
+    uint32_t ephemeralduration_;
+    uint64_t ephemeralstarttimestamp_;
+    int bizprivacystatus_;
+    bool ephemeraloutofsync_;
+    bool statusalreadyviewed_;
+    uint64_t revokemessagetimestamp_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WebNotificationsInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebNotificationsInfo) */ {
+ public:
+  inline WebNotificationsInfo() : WebNotificationsInfo(nullptr) {}
+  ~WebNotificationsInfo() override;
+  explicit PROTOBUF_CONSTEXPR WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WebNotificationsInfo(const WebNotificationsInfo& from);
+  WebNotificationsInfo(WebNotificationsInfo&& from) noexcept
+    : WebNotificationsInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline WebNotificationsInfo& operator=(const WebNotificationsInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WebNotificationsInfo& operator=(WebNotificationsInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WebNotificationsInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WebNotificationsInfo* internal_default_instance() {
+    return reinterpret_cast<const WebNotificationsInfo*>(
+               &_WebNotificationsInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    223;
+
+  friend void swap(WebNotificationsInfo& a, WebNotificationsInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WebNotificationsInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WebNotificationsInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  WebNotificationsInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<WebNotificationsInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WebNotificationsInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const WebNotificationsInfo& from) {
+    WebNotificationsInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WebNotificationsInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "proto.WebNotificationsInfo";
+  }
+  protected:
+  explicit WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNotifyMessagesFieldNumber = 5,
+    kTimestampFieldNumber = 2,
+    kUnreadChatsFieldNumber = 3,
+    kNotifyMessageCountFieldNumber = 4,
+  };
+  // repeated .proto.WebMessageInfo notifyMessages = 5;
+  int notifymessages_size() const;
+  private:
+  int _internal_notifymessages_size() const;
+  public:
+  void clear_notifymessages();
+  ::proto::WebMessageInfo* mutable_notifymessages(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
+      mutable_notifymessages();
+  private:
+  const ::proto::WebMessageInfo& _internal_notifymessages(int index) const;
+  ::proto::WebMessageInfo* _internal_add_notifymessages();
+  public:
+  const ::proto::WebMessageInfo& notifymessages(int index) const;
+  ::proto::WebMessageInfo* add_notifymessages();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
+      notifymessages() const;
+
+  // optional uint64 timestamp = 2;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  uint64_t timestamp() const;
+  void set_timestamp(uint64_t value);
+  private:
+  uint64_t _internal_timestamp() const;
+  void _internal_set_timestamp(uint64_t value);
+  public:
+
+  // optional uint32 unreadChats = 3;
+  bool has_unreadchats() const;
+  private:
+  bool _internal_has_unreadchats() const;
+  public:
+  void clear_unreadchats();
+  uint32_t unreadchats() const;
+  void set_unreadchats(uint32_t value);
+  private:
+  uint32_t _internal_unreadchats() const;
+  void _internal_set_unreadchats(uint32_t value);
+  public:
+
+  // optional uint32 notifyMessageCount = 4;
+  bool has_notifymessagecount() const;
+  private:
+  bool _internal_has_notifymessagecount() const;
+  public:
+  void clear_notifymessagecount();
+  uint32_t notifymessagecount() const;
+  void set_notifymessagecount(uint32_t value);
+  private:
+  uint32_t _internal_notifymessagecount() const;
+  void _internal_set_notifymessagecount(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:proto.WebNotificationsInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > notifymessages_;
+    uint64_t timestamp_;
+    uint32_t unreadchats_;
+    uint32_t notifymessagecount_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_pmsg_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ADVDeviceIdentity
+
+// optional uint32 rawId = 1;
+inline bool ADVDeviceIdentity::_internal_has_rawid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ADVDeviceIdentity::has_rawid() const {
+  return _internal_has_rawid();
+}
+inline void ADVDeviceIdentity::clear_rawid() {
+  _impl_.rawid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t ADVDeviceIdentity::_internal_rawid() const {
+  return _impl_.rawid_;
+}
+inline uint32_t ADVDeviceIdentity::rawid() const {
+  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.rawId)
+  return _internal_rawid();
+}
+inline void ADVDeviceIdentity::_internal_set_rawid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.rawid_ = value;
+}
+inline void ADVDeviceIdentity::set_rawid(uint32_t value) {
+  _internal_set_rawid(value);
+  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.rawId)
+}
+
+// optional uint64 timestamp = 2;
+inline bool ADVDeviceIdentity::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ADVDeviceIdentity::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void ADVDeviceIdentity::clear_timestamp() {
+  _impl_.timestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t ADVDeviceIdentity::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline uint64_t ADVDeviceIdentity::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.timestamp)
+  return _internal_timestamp();
+}
+inline void ADVDeviceIdentity::_internal_set_timestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void ADVDeviceIdentity::set_timestamp(uint64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.timestamp)
+}
+
+// optional uint32 keyIndex = 3;
+inline bool ADVDeviceIdentity::_internal_has_keyindex() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ADVDeviceIdentity::has_keyindex() const {
+  return _internal_has_keyindex();
+}
+inline void ADVDeviceIdentity::clear_keyindex() {
+  _impl_.keyindex_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ADVDeviceIdentity::_internal_keyindex() const {
+  return _impl_.keyindex_;
+}
+inline uint32_t ADVDeviceIdentity::keyindex() const {
+  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.keyIndex)
+  return _internal_keyindex();
+}
+inline void ADVDeviceIdentity::_internal_set_keyindex(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.keyindex_ = value;
+}
+inline void ADVDeviceIdentity::set_keyindex(uint32_t value) {
+  _internal_set_keyindex(value);
+  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.keyIndex)
+}
+
+// -------------------------------------------------------------------
+
+// ADVKeyIndexList
+
+// optional uint32 rawId = 1;
+inline bool ADVKeyIndexList::_internal_has_rawid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ADVKeyIndexList::has_rawid() const {
+  return _internal_has_rawid();
+}
+inline void ADVKeyIndexList::clear_rawid() {
+  _impl_.rawid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t ADVKeyIndexList::_internal_rawid() const {
+  return _impl_.rawid_;
+}
+inline uint32_t ADVKeyIndexList::rawid() const {
+  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.rawId)
+  return _internal_rawid();
+}
+inline void ADVKeyIndexList::_internal_set_rawid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.rawid_ = value;
+}
+inline void ADVKeyIndexList::set_rawid(uint32_t value) {
+  _internal_set_rawid(value);
+  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.rawId)
+}
+
+// optional uint64 timestamp = 2;
+inline bool ADVKeyIndexList::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ADVKeyIndexList::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void ADVKeyIndexList::clear_timestamp() {
+  _impl_.timestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t ADVKeyIndexList::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline uint64_t ADVKeyIndexList::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.timestamp)
+  return _internal_timestamp();
+}
+inline void ADVKeyIndexList::_internal_set_timestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void ADVKeyIndexList::set_timestamp(uint64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.timestamp)
+}
+
+// optional uint32 currentIndex = 3;
+inline bool ADVKeyIndexList::_internal_has_currentindex() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ADVKeyIndexList::has_currentindex() const {
+  return _internal_has_currentindex();
+}
+inline void ADVKeyIndexList::clear_currentindex() {
+  _impl_.currentindex_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ADVKeyIndexList::_internal_currentindex() const {
+  return _impl_.currentindex_;
+}
+inline uint32_t ADVKeyIndexList::currentindex() const {
+  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.currentIndex)
+  return _internal_currentindex();
+}
+inline void ADVKeyIndexList::_internal_set_currentindex(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.currentindex_ = value;
+}
+inline void ADVKeyIndexList::set_currentindex(uint32_t value) {
+  _internal_set_currentindex(value);
+  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.currentIndex)
+}
+
+// repeated uint32 validIndexes = 4 [packed = true];
+inline int ADVKeyIndexList::_internal_validindexes_size() const {
+  return _impl_.validindexes_.size();
+}
+inline int ADVKeyIndexList::validindexes_size() const {
+  return _internal_validindexes_size();
+}
+inline void ADVKeyIndexList::clear_validindexes() {
+  _impl_.validindexes_.Clear();
+}
+inline uint32_t ADVKeyIndexList::_internal_validindexes(int index) const {
+  return _impl_.validindexes_.Get(index);
+}
+inline uint32_t ADVKeyIndexList::validindexes(int index) const {
+  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.validIndexes)
+  return _internal_validindexes(index);
+}
+inline void ADVKeyIndexList::set_validindexes(int index, uint32_t value) {
+  _impl_.validindexes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.validIndexes)
+}
+inline void ADVKeyIndexList::_internal_add_validindexes(uint32_t value) {
+  _impl_.validindexes_.Add(value);
+}
+inline void ADVKeyIndexList::add_validindexes(uint32_t value) {
+  _internal_add_validindexes(value);
+  // @@protoc_insertion_point(field_add:proto.ADVKeyIndexList.validIndexes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ADVKeyIndexList::_internal_validindexes() const {
+  return _impl_.validindexes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ADVKeyIndexList::validindexes() const {
+  // @@protoc_insertion_point(field_list:proto.ADVKeyIndexList.validIndexes)
+  return _internal_validindexes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ADVKeyIndexList::_internal_mutable_validindexes() {
+  return &_impl_.validindexes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ADVKeyIndexList::mutable_validindexes() {
+  // @@protoc_insertion_point(field_mutable_list:proto.ADVKeyIndexList.validIndexes)
+  return _internal_mutable_validindexes();
+}
+
+// -------------------------------------------------------------------
+
+// ADVSignedDeviceIdentity
+
+// optional bytes details = 1;
+inline bool ADVSignedDeviceIdentity::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentity::has_details() const {
+  return _internal_has_details();
+}
+inline void ADVSignedDeviceIdentity::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ADVSignedDeviceIdentity::details() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentity::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.details)
+}
+inline std::string* ADVSignedDeviceIdentity::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.details)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentity::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void ADVSignedDeviceIdentity::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::release_details() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentity::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.details)
+}
+
+// optional bytes accountSignatureKey = 2;
+inline bool ADVSignedDeviceIdentity::_internal_has_accountsignaturekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentity::has_accountsignaturekey() const {
+  return _internal_has_accountsignaturekey();
+}
+inline void ADVSignedDeviceIdentity::clear_accountsignaturekey() {
+  _impl_.accountsignaturekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ADVSignedDeviceIdentity::accountsignaturekey() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignatureKey)
+  return _internal_accountsignaturekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentity::set_accountsignaturekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.accountsignaturekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignatureKey)
+}
+inline std::string* ADVSignedDeviceIdentity::mutable_accountsignaturekey() {
+  std::string* _s = _internal_mutable_accountsignaturekey();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignatureKey)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignaturekey() const {
+  return _impl_.accountsignaturekey_.Get();
+}
+inline void ADVSignedDeviceIdentity::_internal_set_accountsignaturekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.accountsignaturekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignaturekey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.accountsignaturekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::release_accountsignaturekey() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignatureKey)
+  if (!_internal_has_accountsignaturekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.accountsignaturekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignaturekey_.IsDefault()) {
+    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentity::set_allocated_accountsignaturekey(std::string* accountsignaturekey) {
+  if (accountsignaturekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.accountsignaturekey_.SetAllocated(accountsignaturekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignaturekey_.IsDefault()) {
+    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignatureKey)
+}
+
+// optional bytes accountSignature = 3;
+inline bool ADVSignedDeviceIdentity::_internal_has_accountsignature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentity::has_accountsignature() const {
+  return _internal_has_accountsignature();
+}
+inline void ADVSignedDeviceIdentity::clear_accountsignature() {
+  _impl_.accountsignature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ADVSignedDeviceIdentity::accountsignature() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignature)
+  return _internal_accountsignature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentity::set_accountsignature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.accountsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignature)
+}
+inline std::string* ADVSignedDeviceIdentity::mutable_accountsignature() {
+  std::string* _s = _internal_mutable_accountsignature();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignature)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignature() const {
+  return _impl_.accountsignature_.Get();
+}
+inline void ADVSignedDeviceIdentity::_internal_set_accountsignature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.accountsignature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignature() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.accountsignature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::release_accountsignature() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignature)
+  if (!_internal_has_accountsignature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.accountsignature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignature_.IsDefault()) {
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentity::set_allocated_accountsignature(std::string* accountsignature) {
+  if (accountsignature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignature_.IsDefault()) {
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignature)
+}
+
+// optional bytes deviceSignature = 4;
+inline bool ADVSignedDeviceIdentity::_internal_has_devicesignature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentity::has_devicesignature() const {
+  return _internal_has_devicesignature();
+}
+inline void ADVSignedDeviceIdentity::clear_devicesignature() {
+  _impl_.devicesignature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ADVSignedDeviceIdentity::devicesignature() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.deviceSignature)
+  return _internal_devicesignature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentity::set_devicesignature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.devicesignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.deviceSignature)
+}
+inline std::string* ADVSignedDeviceIdentity::mutable_devicesignature() {
+  std::string* _s = _internal_mutable_devicesignature();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.deviceSignature)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentity::_internal_devicesignature() const {
+  return _impl_.devicesignature_.Get();
+}
+inline void ADVSignedDeviceIdentity::_internal_set_devicesignature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.devicesignature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::_internal_mutable_devicesignature() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.devicesignature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentity::release_devicesignature() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.deviceSignature)
+  if (!_internal_has_devicesignature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.devicesignature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.devicesignature_.IsDefault()) {
+    _impl_.devicesignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentity::set_allocated_devicesignature(std::string* devicesignature) {
+  if (devicesignature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.devicesignature_.SetAllocated(devicesignature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.devicesignature_.IsDefault()) {
+    _impl_.devicesignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.deviceSignature)
+}
+
+// -------------------------------------------------------------------
+
+// ADVSignedDeviceIdentityHMAC
+
+// optional bytes details = 1;
+inline bool ADVSignedDeviceIdentityHMAC::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentityHMAC::has_details() const {
+  return _internal_has_details();
+}
+inline void ADVSignedDeviceIdentityHMAC::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ADVSignedDeviceIdentityHMAC::details() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentityHMAC::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.details)
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.details)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void ADVSignedDeviceIdentityHMAC::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::release_details() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentityHMAC::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.details)
+}
+
+// optional bytes hmac = 2;
+inline bool ADVSignedDeviceIdentityHMAC::_internal_has_hmac() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ADVSignedDeviceIdentityHMAC::has_hmac() const {
+  return _internal_has_hmac();
+}
+inline void ADVSignedDeviceIdentityHMAC::clear_hmac() {
+  _impl_.hmac_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ADVSignedDeviceIdentityHMAC::hmac() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.hmac)
+  return _internal_hmac();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedDeviceIdentityHMAC::set_hmac(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.hmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.hmac)
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::mutable_hmac() {
+  std::string* _s = _internal_mutable_hmac();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.hmac)
+  return _s;
+}
+inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_hmac() const {
+  return _impl_.hmac_.Get();
+}
+inline void ADVSignedDeviceIdentityHMAC::_internal_set_hmac(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.hmac_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_hmac() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.hmac_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedDeviceIdentityHMAC::release_hmac() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.hmac)
+  if (!_internal_has_hmac()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.hmac_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hmac_.IsDefault()) {
+    _impl_.hmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedDeviceIdentityHMAC::set_allocated_hmac(std::string* hmac) {
+  if (hmac != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.hmac_.SetAllocated(hmac, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hmac_.IsDefault()) {
+    _impl_.hmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.hmac)
+}
+
+// -------------------------------------------------------------------
+
+// ADVSignedKeyIndexList
+
+// optional bytes details = 1;
+inline bool ADVSignedKeyIndexList::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ADVSignedKeyIndexList::has_details() const {
+  return _internal_has_details();
+}
+inline void ADVSignedKeyIndexList::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ADVSignedKeyIndexList::details() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedKeyIndexList::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.details)
+}
+inline std::string* ADVSignedKeyIndexList::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.details)
+  return _s;
+}
+inline const std::string& ADVSignedKeyIndexList::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void ADVSignedKeyIndexList::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedKeyIndexList::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedKeyIndexList::release_details() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedKeyIndexList::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.details)
+}
+
+// optional bytes accountSignature = 2;
+inline bool ADVSignedKeyIndexList::_internal_has_accountsignature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ADVSignedKeyIndexList::has_accountsignature() const {
+  return _internal_has_accountsignature();
+}
+inline void ADVSignedKeyIndexList::clear_accountsignature() {
+  _impl_.accountsignature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ADVSignedKeyIndexList::accountsignature() const {
+  // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.accountSignature)
+  return _internal_accountsignature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ADVSignedKeyIndexList::set_accountsignature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.accountsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.accountSignature)
+}
+inline std::string* ADVSignedKeyIndexList::mutable_accountsignature() {
+  std::string* _s = _internal_mutable_accountsignature();
+  // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.accountSignature)
+  return _s;
+}
+inline const std::string& ADVSignedKeyIndexList::_internal_accountsignature() const {
+  return _impl_.accountsignature_.Get();
+}
+inline void ADVSignedKeyIndexList::_internal_set_accountsignature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.accountsignature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ADVSignedKeyIndexList::_internal_mutable_accountsignature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.accountsignature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ADVSignedKeyIndexList::release_accountsignature() {
+  // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.accountSignature)
+  if (!_internal_has_accountsignature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.accountsignature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignature_.IsDefault()) {
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ADVSignedKeyIndexList::set_allocated_accountsignature(std::string* accountsignature) {
+  if (accountsignature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.accountsignature_.IsDefault()) {
+    _impl_.accountsignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.accountSignature)
+}
+
+// -------------------------------------------------------------------
+
+// ActionLink
+
+// optional string url = 1;
+inline bool ActionLink::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ActionLink::has_url() const {
+  return _internal_has_url();
+}
+inline void ActionLink::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ActionLink::url() const {
+  // @@protoc_insertion_point(field_get:proto.ActionLink.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ActionLink::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ActionLink.url)
+}
+inline std::string* ActionLink::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.ActionLink.url)
+  return _s;
+}
+inline const std::string& ActionLink::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ActionLink::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ActionLink::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ActionLink::release_url() {
+  // @@protoc_insertion_point(field_release:proto.ActionLink.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ActionLink::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.url)
+}
+
+// optional string buttonTitle = 2;
+inline bool ActionLink::_internal_has_buttontitle() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ActionLink::has_buttontitle() const {
+  return _internal_has_buttontitle();
+}
+inline void ActionLink::clear_buttontitle() {
+  _impl_.buttontitle_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ActionLink::buttontitle() const {
+  // @@protoc_insertion_point(field_get:proto.ActionLink.buttonTitle)
+  return _internal_buttontitle();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ActionLink::set_buttontitle(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.buttontitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ActionLink.buttonTitle)
+}
+inline std::string* ActionLink::mutable_buttontitle() {
+  std::string* _s = _internal_mutable_buttontitle();
+  // @@protoc_insertion_point(field_mutable:proto.ActionLink.buttonTitle)
+  return _s;
+}
+inline const std::string& ActionLink::_internal_buttontitle() const {
+  return _impl_.buttontitle_.Get();
+}
+inline void ActionLink::_internal_set_buttontitle(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.buttontitle_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ActionLink::_internal_mutable_buttontitle() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.buttontitle_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ActionLink::release_buttontitle() {
+  // @@protoc_insertion_point(field_release:proto.ActionLink.buttonTitle)
+  if (!_internal_has_buttontitle()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.buttontitle_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttontitle_.IsDefault()) {
+    _impl_.buttontitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ActionLink::set_allocated_buttontitle(std::string* buttontitle) {
+  if (buttontitle != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.buttontitle_.SetAllocated(buttontitle, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttontitle_.IsDefault()) {
+    _impl_.buttontitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.buttonTitle)
+}
+
+// -------------------------------------------------------------------
+
+// AutoDownloadSettings
+
+// optional bool downloadImages = 1;
+inline bool AutoDownloadSettings::_internal_has_downloadimages() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool AutoDownloadSettings::has_downloadimages() const {
+  return _internal_has_downloadimages();
+}
+inline void AutoDownloadSettings::clear_downloadimages() {
+  _impl_.downloadimages_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool AutoDownloadSettings::_internal_downloadimages() const {
+  return _impl_.downloadimages_;
+}
+inline bool AutoDownloadSettings::downloadimages() const {
+  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadImages)
+  return _internal_downloadimages();
+}
+inline void AutoDownloadSettings::_internal_set_downloadimages(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.downloadimages_ = value;
+}
+inline void AutoDownloadSettings::set_downloadimages(bool value) {
+  _internal_set_downloadimages(value);
+  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadImages)
+}
+
+// optional bool downloadAudio = 2;
+inline bool AutoDownloadSettings::_internal_has_downloadaudio() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool AutoDownloadSettings::has_downloadaudio() const {
+  return _internal_has_downloadaudio();
+}
+inline void AutoDownloadSettings::clear_downloadaudio() {
+  _impl_.downloadaudio_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool AutoDownloadSettings::_internal_downloadaudio() const {
+  return _impl_.downloadaudio_;
+}
+inline bool AutoDownloadSettings::downloadaudio() const {
+  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadAudio)
+  return _internal_downloadaudio();
+}
+inline void AutoDownloadSettings::_internal_set_downloadaudio(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.downloadaudio_ = value;
+}
+inline void AutoDownloadSettings::set_downloadaudio(bool value) {
+  _internal_set_downloadaudio(value);
+  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadAudio)
+}
+
+// optional bool downloadVideo = 3;
+inline bool AutoDownloadSettings::_internal_has_downloadvideo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool AutoDownloadSettings::has_downloadvideo() const {
+  return _internal_has_downloadvideo();
+}
+inline void AutoDownloadSettings::clear_downloadvideo() {
+  _impl_.downloadvideo_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool AutoDownloadSettings::_internal_downloadvideo() const {
+  return _impl_.downloadvideo_;
+}
+inline bool AutoDownloadSettings::downloadvideo() const {
+  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadVideo)
+  return _internal_downloadvideo();
+}
+inline void AutoDownloadSettings::_internal_set_downloadvideo(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.downloadvideo_ = value;
+}
+inline void AutoDownloadSettings::set_downloadvideo(bool value) {
+  _internal_set_downloadvideo(value);
+  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadVideo)
+}
+
+// optional bool downloadDocuments = 4;
+inline bool AutoDownloadSettings::_internal_has_downloaddocuments() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool AutoDownloadSettings::has_downloaddocuments() const {
+  return _internal_has_downloaddocuments();
+}
+inline void AutoDownloadSettings::clear_downloaddocuments() {
+  _impl_.downloaddocuments_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool AutoDownloadSettings::_internal_downloaddocuments() const {
+  return _impl_.downloaddocuments_;
+}
+inline bool AutoDownloadSettings::downloaddocuments() const {
+  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadDocuments)
+  return _internal_downloaddocuments();
+}
+inline void AutoDownloadSettings::_internal_set_downloaddocuments(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.downloaddocuments_ = value;
+}
+inline void AutoDownloadSettings::set_downloaddocuments(bool value) {
+  _internal_set_downloaddocuments(value);
+  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadDocuments)
+}
+
+// -------------------------------------------------------------------
+
+// BizAccountLinkInfo
+
+// optional uint64 whatsappBizAcctFbid = 1;
+inline bool BizAccountLinkInfo::_internal_has_whatsappbizacctfbid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool BizAccountLinkInfo::has_whatsappbizacctfbid() const {
+  return _internal_has_whatsappbizacctfbid();
+}
+inline void BizAccountLinkInfo::clear_whatsappbizacctfbid() {
+  _impl_.whatsappbizacctfbid_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t BizAccountLinkInfo::_internal_whatsappbizacctfbid() const {
+  return _impl_.whatsappbizacctfbid_;
+}
+inline uint64_t BizAccountLinkInfo::whatsappbizacctfbid() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappBizAcctFbid)
+  return _internal_whatsappbizacctfbid();
+}
+inline void BizAccountLinkInfo::_internal_set_whatsappbizacctfbid(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.whatsappbizacctfbid_ = value;
+}
+inline void BizAccountLinkInfo::set_whatsappbizacctfbid(uint64_t value) {
+  _internal_set_whatsappbizacctfbid(value);
+  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappBizAcctFbid)
+}
+
+// optional string whatsappAcctNumber = 2;
+inline bool BizAccountLinkInfo::_internal_has_whatsappacctnumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool BizAccountLinkInfo::has_whatsappacctnumber() const {
+  return _internal_has_whatsappacctnumber();
+}
+inline void BizAccountLinkInfo::clear_whatsappacctnumber() {
+  _impl_.whatsappacctnumber_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& BizAccountLinkInfo::whatsappacctnumber() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappAcctNumber)
+  return _internal_whatsappacctnumber();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BizAccountLinkInfo::set_whatsappacctnumber(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.whatsappacctnumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappAcctNumber)
+}
+inline std::string* BizAccountLinkInfo::mutable_whatsappacctnumber() {
+  std::string* _s = _internal_mutable_whatsappacctnumber();
+  // @@protoc_insertion_point(field_mutable:proto.BizAccountLinkInfo.whatsappAcctNumber)
+  return _s;
+}
+inline const std::string& BizAccountLinkInfo::_internal_whatsappacctnumber() const {
+  return _impl_.whatsappacctnumber_.Get();
+}
+inline void BizAccountLinkInfo::_internal_set_whatsappacctnumber(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.whatsappacctnumber_.Set(value, GetArenaForAllocation());
+}
+inline std::string* BizAccountLinkInfo::_internal_mutable_whatsappacctnumber() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.whatsappacctnumber_.Mutable(GetArenaForAllocation());
+}
+inline std::string* BizAccountLinkInfo::release_whatsappacctnumber() {
+  // @@protoc_insertion_point(field_release:proto.BizAccountLinkInfo.whatsappAcctNumber)
+  if (!_internal_has_whatsappacctnumber()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.whatsappacctnumber_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.whatsappacctnumber_.IsDefault()) {
+    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void BizAccountLinkInfo::set_allocated_whatsappacctnumber(std::string* whatsappacctnumber) {
+  if (whatsappacctnumber != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.whatsappacctnumber_.SetAllocated(whatsappacctnumber, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.whatsappacctnumber_.IsDefault()) {
+    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountLinkInfo.whatsappAcctNumber)
+}
+
+// optional uint64 issueTime = 3;
+inline bool BizAccountLinkInfo::_internal_has_issuetime() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool BizAccountLinkInfo::has_issuetime() const {
+  return _internal_has_issuetime();
+}
+inline void BizAccountLinkInfo::clear_issuetime() {
+  _impl_.issuetime_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint64_t BizAccountLinkInfo::_internal_issuetime() const {
+  return _impl_.issuetime_;
+}
+inline uint64_t BizAccountLinkInfo::issuetime() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.issueTime)
+  return _internal_issuetime();
+}
+inline void BizAccountLinkInfo::_internal_set_issuetime(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.issuetime_ = value;
+}
+inline void BizAccountLinkInfo::set_issuetime(uint64_t value) {
+  _internal_set_issuetime(value);
+  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.issueTime)
+}
+
+// optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
+inline bool BizAccountLinkInfo::_internal_has_hoststorage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool BizAccountLinkInfo::has_hoststorage() const {
+  return _internal_has_hoststorage();
+}
+inline void BizAccountLinkInfo::clear_hoststorage() {
+  _impl_.hoststorage_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::_internal_hoststorage() const {
+  return static_cast< ::proto::BizAccountLinkInfo_HostStorageType >(_impl_.hoststorage_);
+}
+inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::hoststorage() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.hostStorage)
+  return _internal_hoststorage();
+}
+inline void BizAccountLinkInfo::_internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) {
+  assert(::proto::BizAccountLinkInfo_HostStorageType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.hoststorage_ = value;
+}
+inline void BizAccountLinkInfo::set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) {
+  _internal_set_hoststorage(value);
+  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.hostStorage)
+}
+
+// optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
+inline bool BizAccountLinkInfo::_internal_has_accounttype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool BizAccountLinkInfo::has_accounttype() const {
+  return _internal_has_accounttype();
+}
+inline void BizAccountLinkInfo::clear_accounttype() {
+  _impl_.accounttype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::_internal_accounttype() const {
+  return static_cast< ::proto::BizAccountLinkInfo_AccountType >(_impl_.accounttype_);
+}
+inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::accounttype() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.accountType)
+  return _internal_accounttype();
+}
+inline void BizAccountLinkInfo::_internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value) {
+  assert(::proto::BizAccountLinkInfo_AccountType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.accounttype_ = value;
+}
+inline void BizAccountLinkInfo::set_accounttype(::proto::BizAccountLinkInfo_AccountType value) {
+  _internal_set_accounttype(value);
+  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.accountType)
+}
+
+// -------------------------------------------------------------------
+
+// BizAccountPayload
+
+// optional .proto.VerifiedNameCertificate vnameCert = 1;
+inline bool BizAccountPayload::_internal_has_vnamecert() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr);
+  return value;
+}
+inline bool BizAccountPayload::has_vnamecert() const {
+  return _internal_has_vnamecert();
+}
+inline void BizAccountPayload::clear_vnamecert() {
+  if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::VerifiedNameCertificate& BizAccountPayload::_internal_vnamecert() const {
+  const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::VerifiedNameCertificate&>(
+      ::proto::_VerifiedNameCertificate_default_instance_);
+}
+inline const ::proto::VerifiedNameCertificate& BizAccountPayload::vnamecert() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountPayload.vnameCert)
+  return _internal_vnamecert();
+}
+inline void BizAccountPayload::unsafe_arena_set_allocated_vnamecert(
+    ::proto::VerifiedNameCertificate* vnamecert) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_);
+  }
+  _impl_.vnamecert_ = vnamecert;
+  if (vnamecert) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizAccountPayload.vnameCert)
+}
+inline ::proto::VerifiedNameCertificate* BizAccountPayload::release_vnamecert() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
+  _impl_.vnamecert_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::VerifiedNameCertificate* BizAccountPayload::unsafe_arena_release_vnamecert() {
+  // @@protoc_insertion_point(field_release:proto.BizAccountPayload.vnameCert)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
+  _impl_.vnamecert_ = nullptr;
+  return temp;
+}
+inline ::proto::VerifiedNameCertificate* BizAccountPayload::_internal_mutable_vnamecert() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.vnamecert_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation());
+    _impl_.vnamecert_ = p;
+  }
+  return _impl_.vnamecert_;
+}
+inline ::proto::VerifiedNameCertificate* BizAccountPayload::mutable_vnamecert() {
+  ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert();
+  // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.vnameCert)
+  return _msg;
+}
+inline void BizAccountPayload::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.vnamecert_;
+  }
+  if (vnamecert) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert);
+    if (message_arena != submessage_arena) {
+      vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, vnamecert, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.vnamecert_ = vnamecert;
+  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.vnameCert)
+}
+
+// optional bytes bizAcctLinkInfo = 2;
+inline bool BizAccountPayload::_internal_has_bizacctlinkinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool BizAccountPayload::has_bizacctlinkinfo() const {
+  return _internal_has_bizacctlinkinfo();
+}
+inline void BizAccountPayload::clear_bizacctlinkinfo() {
+  _impl_.bizacctlinkinfo_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& BizAccountPayload::bizacctlinkinfo() const {
+  // @@protoc_insertion_point(field_get:proto.BizAccountPayload.bizAcctLinkInfo)
+  return _internal_bizacctlinkinfo();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BizAccountPayload::set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.bizacctlinkinfo_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.BizAccountPayload.bizAcctLinkInfo)
+}
+inline std::string* BizAccountPayload::mutable_bizacctlinkinfo() {
+  std::string* _s = _internal_mutable_bizacctlinkinfo();
+  // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.bizAcctLinkInfo)
+  return _s;
+}
+inline const std::string& BizAccountPayload::_internal_bizacctlinkinfo() const {
+  return _impl_.bizacctlinkinfo_.Get();
+}
+inline void BizAccountPayload::_internal_set_bizacctlinkinfo(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.bizacctlinkinfo_.Set(value, GetArenaForAllocation());
+}
+inline std::string* BizAccountPayload::_internal_mutable_bizacctlinkinfo() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.bizacctlinkinfo_.Mutable(GetArenaForAllocation());
+}
+inline std::string* BizAccountPayload::release_bizacctlinkinfo() {
+  // @@protoc_insertion_point(field_release:proto.BizAccountPayload.bizAcctLinkInfo)
+  if (!_internal_has_bizacctlinkinfo()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.bizacctlinkinfo_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bizacctlinkinfo_.IsDefault()) {
+    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void BizAccountPayload::set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo) {
+  if (bizacctlinkinfo != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.bizacctlinkinfo_.SetAllocated(bizacctlinkinfo, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bizacctlinkinfo_.IsDefault()) {
+    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.bizAcctLinkInfo)
+}
+
+// -------------------------------------------------------------------
+
+// BizIdentityInfo
+
+// optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
+inline bool BizIdentityInfo::_internal_has_vlevel() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_vlevel() const {
+  return _internal_has_vlevel();
+}
+inline void BizIdentityInfo::clear_vlevel() {
+  _impl_.vlevel_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::_internal_vlevel() const {
+  return static_cast< ::proto::BizIdentityInfo_VerifiedLevelValue >(_impl_.vlevel_);
+}
+inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::vlevel() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vlevel)
+  return _internal_vlevel();
+}
+inline void BizIdentityInfo::_internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) {
+  assert(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.vlevel_ = value;
+}
+inline void BizIdentityInfo::set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) {
+  _internal_set_vlevel(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.vlevel)
+}
+
+// optional .proto.VerifiedNameCertificate vnameCert = 2;
+inline bool BizIdentityInfo::_internal_has_vnamecert() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr);
+  return value;
+}
+inline bool BizIdentityInfo::has_vnamecert() const {
+  return _internal_has_vnamecert();
+}
+inline void BizIdentityInfo::clear_vnamecert() {
+  if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::_internal_vnamecert() const {
+  const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::VerifiedNameCertificate&>(
+      ::proto::_VerifiedNameCertificate_default_instance_);
+}
+inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::vnamecert() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vnameCert)
+  return _internal_vnamecert();
+}
+inline void BizIdentityInfo::unsafe_arena_set_allocated_vnamecert(
+    ::proto::VerifiedNameCertificate* vnamecert) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_);
+  }
+  _impl_.vnamecert_ = vnamecert;
+  if (vnamecert) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizIdentityInfo.vnameCert)
+}
+inline ::proto::VerifiedNameCertificate* BizIdentityInfo::release_vnamecert() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
+  _impl_.vnamecert_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::VerifiedNameCertificate* BizIdentityInfo::unsafe_arena_release_vnamecert() {
+  // @@protoc_insertion_point(field_release:proto.BizIdentityInfo.vnameCert)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
+  _impl_.vnamecert_ = nullptr;
+  return temp;
+}
+inline ::proto::VerifiedNameCertificate* BizIdentityInfo::_internal_mutable_vnamecert() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.vnamecert_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation());
+    _impl_.vnamecert_ = p;
+  }
+  return _impl_.vnamecert_;
+}
+inline ::proto::VerifiedNameCertificate* BizIdentityInfo::mutable_vnamecert() {
+  ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert();
+  // @@protoc_insertion_point(field_mutable:proto.BizIdentityInfo.vnameCert)
+  return _msg;
+}
+inline void BizIdentityInfo::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.vnamecert_;
+  }
+  if (vnamecert) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert);
+    if (message_arena != submessage_arena) {
+      vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, vnamecert, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.vnamecert_ = vnamecert;
+  // @@protoc_insertion_point(field_set_allocated:proto.BizIdentityInfo.vnameCert)
+}
+
+// optional bool signed = 3;
+inline bool BizIdentityInfo::_internal_has_signed_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_signed_() const {
+  return _internal_has_signed_();
+}
+inline void BizIdentityInfo::clear_signed_() {
+  _impl_.signed__ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool BizIdentityInfo::_internal_signed_() const {
+  return _impl_.signed__;
+}
+inline bool BizIdentityInfo::signed_() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.signed)
+  return _internal_signed_();
+}
+inline void BizIdentityInfo::_internal_set_signed_(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.signed__ = value;
+}
+inline void BizIdentityInfo::set_signed_(bool value) {
+  _internal_set_signed_(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.signed)
+}
+
+// optional bool revoked = 4;
+inline bool BizIdentityInfo::_internal_has_revoked() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_revoked() const {
+  return _internal_has_revoked();
+}
+inline void BizIdentityInfo::clear_revoked() {
+  _impl_.revoked_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool BizIdentityInfo::_internal_revoked() const {
+  return _impl_.revoked_;
+}
+inline bool BizIdentityInfo::revoked() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.revoked)
+  return _internal_revoked();
+}
+inline void BizIdentityInfo::_internal_set_revoked(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.revoked_ = value;
+}
+inline void BizIdentityInfo::set_revoked(bool value) {
+  _internal_set_revoked(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.revoked)
+}
+
+// optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
+inline bool BizIdentityInfo::_internal_has_hoststorage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_hoststorage() const {
+  return _internal_has_hoststorage();
+}
+inline void BizIdentityInfo::clear_hoststorage() {
+  _impl_.hoststorage_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::_internal_hoststorage() const {
+  return static_cast< ::proto::BizIdentityInfo_HostStorageType >(_impl_.hoststorage_);
+}
+inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::hoststorage() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.hostStorage)
+  return _internal_hoststorage();
+}
+inline void BizIdentityInfo::_internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) {
+  assert(::proto::BizIdentityInfo_HostStorageType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.hoststorage_ = value;
+}
+inline void BizIdentityInfo::set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) {
+  _internal_set_hoststorage(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.hostStorage)
+}
+
+// optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
+inline bool BizIdentityInfo::_internal_has_actualactors() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_actualactors() const {
+  return _internal_has_actualactors();
+}
+inline void BizIdentityInfo::clear_actualactors() {
+  _impl_.actualactors_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::_internal_actualactors() const {
+  return static_cast< ::proto::BizIdentityInfo_ActualActorsType >(_impl_.actualactors_);
+}
+inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::actualactors() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.actualActors)
+  return _internal_actualactors();
+}
+inline void BizIdentityInfo::_internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) {
+  assert(::proto::BizIdentityInfo_ActualActorsType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.actualactors_ = value;
+}
+inline void BizIdentityInfo::set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) {
+  _internal_set_actualactors(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.actualActors)
+}
+
+// optional uint64 privacyModeTs = 7;
+inline bool BizIdentityInfo::_internal_has_privacymodets() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_privacymodets() const {
+  return _internal_has_privacymodets();
+}
+inline void BizIdentityInfo::clear_privacymodets() {
+  _impl_.privacymodets_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint64_t BizIdentityInfo::_internal_privacymodets() const {
+  return _impl_.privacymodets_;
+}
+inline uint64_t BizIdentityInfo::privacymodets() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.privacyModeTs)
+  return _internal_privacymodets();
+}
+inline void BizIdentityInfo::_internal_set_privacymodets(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.privacymodets_ = value;
+}
+inline void BizIdentityInfo::set_privacymodets(uint64_t value) {
+  _internal_set_privacymodets(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.privacyModeTs)
+}
+
+// optional uint64 featureControls = 8;
+inline bool BizIdentityInfo::_internal_has_featurecontrols() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool BizIdentityInfo::has_featurecontrols() const {
+  return _internal_has_featurecontrols();
+}
+inline void BizIdentityInfo::clear_featurecontrols() {
+  _impl_.featurecontrols_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint64_t BizIdentityInfo::_internal_featurecontrols() const {
+  return _impl_.featurecontrols_;
+}
+inline uint64_t BizIdentityInfo::featurecontrols() const {
+  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.featureControls)
+  return _internal_featurecontrols();
+}
+inline void BizIdentityInfo::_internal_set_featurecontrols(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.featurecontrols_ = value;
+}
+inline void BizIdentityInfo::set_featurecontrols(uint64_t value) {
+  _internal_set_featurecontrols(value);
+  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.featureControls)
+}
+
+// -------------------------------------------------------------------
+
+// CertChain_NoiseCertificate_Details
+
+// optional uint32 serial = 1;
+inline bool CertChain_NoiseCertificate_Details::_internal_has_serial() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate_Details::has_serial() const {
+  return _internal_has_serial();
+}
+inline void CertChain_NoiseCertificate_Details::clear_serial() {
+  _impl_.serial_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t CertChain_NoiseCertificate_Details::_internal_serial() const {
+  return _impl_.serial_;
+}
+inline uint32_t CertChain_NoiseCertificate_Details::serial() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.serial)
+  return _internal_serial();
+}
+inline void CertChain_NoiseCertificate_Details::_internal_set_serial(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.serial_ = value;
+}
+inline void CertChain_NoiseCertificate_Details::set_serial(uint32_t value) {
+  _internal_set_serial(value);
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.serial)
+}
+
+// optional uint32 issuerSerial = 2;
+inline bool CertChain_NoiseCertificate_Details::_internal_has_issuerserial() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate_Details::has_issuerserial() const {
+  return _internal_has_issuerserial();
+}
+inline void CertChain_NoiseCertificate_Details::clear_issuerserial() {
+  _impl_.issuerserial_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t CertChain_NoiseCertificate_Details::_internal_issuerserial() const {
+  return _impl_.issuerserial_;
+}
+inline uint32_t CertChain_NoiseCertificate_Details::issuerserial() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.issuerSerial)
+  return _internal_issuerserial();
+}
+inline void CertChain_NoiseCertificate_Details::_internal_set_issuerserial(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.issuerserial_ = value;
+}
+inline void CertChain_NoiseCertificate_Details::set_issuerserial(uint32_t value) {
+  _internal_set_issuerserial(value);
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.issuerSerial)
+}
+
+// optional bytes key = 3;
+inline bool CertChain_NoiseCertificate_Details::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate_Details::has_key() const {
+  return _internal_has_key();
+}
+inline void CertChain_NoiseCertificate_Details::clear_key() {
+  _impl_.key_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CertChain_NoiseCertificate_Details::key() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CertChain_NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.key)
+}
+inline std::string* CertChain_NoiseCertificate_Details::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.Details.key)
+  return _s;
+}
+inline const std::string& CertChain_NoiseCertificate_Details::_internal_key() const {
+  return _impl_.key_.Get();
+}
+inline void CertChain_NoiseCertificate_Details::_internal_set_key(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate_Details::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate_Details::release_key() {
+  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.Details.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.key_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CertChain_NoiseCertificate_Details::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.Details.key)
+}
+
+// optional uint64 notBefore = 4;
+inline bool CertChain_NoiseCertificate_Details::_internal_has_notbefore() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate_Details::has_notbefore() const {
+  return _internal_has_notbefore();
+}
+inline void CertChain_NoiseCertificate_Details::clear_notbefore() {
+  _impl_.notbefore_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t CertChain_NoiseCertificate_Details::_internal_notbefore() const {
+  return _impl_.notbefore_;
+}
+inline uint64_t CertChain_NoiseCertificate_Details::notbefore() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notBefore)
+  return _internal_notbefore();
+}
+inline void CertChain_NoiseCertificate_Details::_internal_set_notbefore(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.notbefore_ = value;
+}
+inline void CertChain_NoiseCertificate_Details::set_notbefore(uint64_t value) {
+  _internal_set_notbefore(value);
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notBefore)
+}
+
+// optional uint64 notAfter = 5;
+inline bool CertChain_NoiseCertificate_Details::_internal_has_notafter() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate_Details::has_notafter() const {
+  return _internal_has_notafter();
+}
+inline void CertChain_NoiseCertificate_Details::clear_notafter() {
+  _impl_.notafter_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint64_t CertChain_NoiseCertificate_Details::_internal_notafter() const {
+  return _impl_.notafter_;
+}
+inline uint64_t CertChain_NoiseCertificate_Details::notafter() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notAfter)
+  return _internal_notafter();
+}
+inline void CertChain_NoiseCertificate_Details::_internal_set_notafter(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.notafter_ = value;
+}
+inline void CertChain_NoiseCertificate_Details::set_notafter(uint64_t value) {
+  _internal_set_notafter(value);
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notAfter)
+}
+
+// -------------------------------------------------------------------
+
+// CertChain_NoiseCertificate
+
+// optional bytes details = 1;
+inline bool CertChain_NoiseCertificate::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate::has_details() const {
+  return _internal_has_details();
+}
+inline void CertChain_NoiseCertificate::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CertChain_NoiseCertificate::details() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CertChain_NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.details)
+}
+inline std::string* CertChain_NoiseCertificate::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.details)
+  return _s;
+}
+inline const std::string& CertChain_NoiseCertificate::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void CertChain_NoiseCertificate::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate::release_details() {
+  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CertChain_NoiseCertificate::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.details)
+}
+
+// optional bytes signature = 2;
+inline bool CertChain_NoiseCertificate::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CertChain_NoiseCertificate::has_signature() const {
+  return _internal_has_signature();
+}
+inline void CertChain_NoiseCertificate::clear_signature() {
+  _impl_.signature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& CertChain_NoiseCertificate::signature() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CertChain_NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.signature)
+}
+inline std::string* CertChain_NoiseCertificate::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.signature)
+  return _s;
+}
+inline const std::string& CertChain_NoiseCertificate::_internal_signature() const {
+  return _impl_.signature_.Get();
+}
+inline void CertChain_NoiseCertificate::_internal_set_signature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.signature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.signature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CertChain_NoiseCertificate::release_signature() {
+  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.signature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CertChain_NoiseCertificate::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.signature)
+}
+
+// -------------------------------------------------------------------
+
+// CertChain
+
+// optional .proto.CertChain.NoiseCertificate leaf = 1;
+inline bool CertChain::_internal_has_leaf() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.leaf_ != nullptr);
+  return value;
+}
+inline bool CertChain::has_leaf() const {
+  return _internal_has_leaf();
+}
+inline void CertChain::clear_leaf() {
+  if (_impl_.leaf_ != nullptr) _impl_.leaf_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_leaf() const {
+  const ::proto::CertChain_NoiseCertificate* p = _impl_.leaf_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::CertChain_NoiseCertificate&>(
+      ::proto::_CertChain_NoiseCertificate_default_instance_);
+}
+inline const ::proto::CertChain_NoiseCertificate& CertChain::leaf() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.leaf)
+  return _internal_leaf();
+}
+inline void CertChain::unsafe_arena_set_allocated_leaf(
+    ::proto::CertChain_NoiseCertificate* leaf) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.leaf_);
+  }
+  _impl_.leaf_ = leaf;
+  if (leaf) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.leaf)
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::release_leaf() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_;
+  _impl_.leaf_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_leaf() {
+  // @@protoc_insertion_point(field_release:proto.CertChain.leaf)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_;
+  _impl_.leaf_ = nullptr;
+  return temp;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_leaf() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.leaf_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation());
+    _impl_.leaf_ = p;
+  }
+  return _impl_.leaf_;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_leaf() {
+  ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_leaf();
+  // @@protoc_insertion_point(field_mutable:proto.CertChain.leaf)
+  return _msg;
+}
+inline void CertChain::set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.leaf_;
+  }
+  if (leaf) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(leaf);
+    if (message_arena != submessage_arena) {
+      leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, leaf, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.leaf_ = leaf;
+  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.leaf)
+}
+
+// optional .proto.CertChain.NoiseCertificate intermediate = 2;
+inline bool CertChain::_internal_has_intermediate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.intermediate_ != nullptr);
+  return value;
+}
+inline bool CertChain::has_intermediate() const {
+  return _internal_has_intermediate();
+}
+inline void CertChain::clear_intermediate() {
+  if (_impl_.intermediate_ != nullptr) _impl_.intermediate_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_intermediate() const {
+  const ::proto::CertChain_NoiseCertificate* p = _impl_.intermediate_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::CertChain_NoiseCertificate&>(
+      ::proto::_CertChain_NoiseCertificate_default_instance_);
+}
+inline const ::proto::CertChain_NoiseCertificate& CertChain::intermediate() const {
+  // @@protoc_insertion_point(field_get:proto.CertChain.intermediate)
+  return _internal_intermediate();
+}
+inline void CertChain::unsafe_arena_set_allocated_intermediate(
+    ::proto::CertChain_NoiseCertificate* intermediate) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.intermediate_);
+  }
+  _impl_.intermediate_ = intermediate;
+  if (intermediate) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.intermediate)
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::release_intermediate() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_;
+  _impl_.intermediate_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_intermediate() {
+  // @@protoc_insertion_point(field_release:proto.CertChain.intermediate)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_;
+  _impl_.intermediate_ = nullptr;
+  return temp;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_intermediate() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.intermediate_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation());
+    _impl_.intermediate_ = p;
+  }
+  return _impl_.intermediate_;
+}
+inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_intermediate() {
+  ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_intermediate();
+  // @@protoc_insertion_point(field_mutable:proto.CertChain.intermediate)
+  return _msg;
+}
+inline void CertChain::set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.intermediate_;
+  }
+  if (intermediate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(intermediate);
+    if (message_arena != submessage_arena) {
+      intermediate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, intermediate, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.intermediate_ = intermediate;
+  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.intermediate)
+}
+
+// -------------------------------------------------------------------
+
+// Chain
+
+// optional bytes senderRatchetKey = 1;
+inline bool Chain::_internal_has_senderratchetkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Chain::has_senderratchetkey() const {
+  return _internal_has_senderratchetkey();
+}
+inline void Chain::clear_senderratchetkey() {
+  _impl_.senderratchetkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Chain::senderratchetkey() const {
+  // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKey)
+  return _internal_senderratchetkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Chain::set_senderratchetkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.senderratchetkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKey)
+}
+inline std::string* Chain::mutable_senderratchetkey() {
+  std::string* _s = _internal_mutable_senderratchetkey();
+  // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKey)
+  return _s;
+}
+inline const std::string& Chain::_internal_senderratchetkey() const {
+  return _impl_.senderratchetkey_.Get();
+}
+inline void Chain::_internal_set_senderratchetkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.senderratchetkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Chain::_internal_mutable_senderratchetkey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.senderratchetkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Chain::release_senderratchetkey() {
+  // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKey)
+  if (!_internal_has_senderratchetkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.senderratchetkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderratchetkey_.IsDefault()) {
+    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Chain::set_allocated_senderratchetkey(std::string* senderratchetkey) {
+  if (senderratchetkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.senderratchetkey_.SetAllocated(senderratchetkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderratchetkey_.IsDefault()) {
+    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKey)
+}
+
+// optional bytes senderRatchetKeyPrivate = 2;
+inline bool Chain::_internal_has_senderratchetkeyprivate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Chain::has_senderratchetkeyprivate() const {
+  return _internal_has_senderratchetkeyprivate();
+}
+inline void Chain::clear_senderratchetkeyprivate() {
+  _impl_.senderratchetkeyprivate_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Chain::senderratchetkeyprivate() const {
+  // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKeyPrivate)
+  return _internal_senderratchetkeyprivate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Chain::set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.senderratchetkeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKeyPrivate)
+}
+inline std::string* Chain::mutable_senderratchetkeyprivate() {
+  std::string* _s = _internal_mutable_senderratchetkeyprivate();
+  // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKeyPrivate)
+  return _s;
+}
+inline const std::string& Chain::_internal_senderratchetkeyprivate() const {
+  return _impl_.senderratchetkeyprivate_.Get();
+}
+inline void Chain::_internal_set_senderratchetkeyprivate(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.senderratchetkeyprivate_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Chain::_internal_mutable_senderratchetkeyprivate() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.senderratchetkeyprivate_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Chain::release_senderratchetkeyprivate() {
+  // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKeyPrivate)
+  if (!_internal_has_senderratchetkeyprivate()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.senderratchetkeyprivate_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderratchetkeyprivate_.IsDefault()) {
+    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Chain::set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate) {
+  if (senderratchetkeyprivate != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.senderratchetkeyprivate_.SetAllocated(senderratchetkeyprivate, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderratchetkeyprivate_.IsDefault()) {
+    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKeyPrivate)
+}
+
+// optional .proto.ChainKey chainKey = 3;
+inline bool Chain::_internal_has_chainkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.chainkey_ != nullptr);
+  return value;
+}
+inline bool Chain::has_chainkey() const {
+  return _internal_has_chainkey();
+}
+inline void Chain::clear_chainkey() {
+  if (_impl_.chainkey_ != nullptr) _impl_.chainkey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ChainKey& Chain::_internal_chainkey() const {
+  const ::proto::ChainKey* p = _impl_.chainkey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ChainKey&>(
+      ::proto::_ChainKey_default_instance_);
+}
+inline const ::proto::ChainKey& Chain::chainkey() const {
+  // @@protoc_insertion_point(field_get:proto.Chain.chainKey)
+  return _internal_chainkey();
+}
+inline void Chain::unsafe_arena_set_allocated_chainkey(
+    ::proto::ChainKey* chainkey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chainkey_);
+  }
+  _impl_.chainkey_ = chainkey;
+  if (chainkey) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Chain.chainKey)
+}
+inline ::proto::ChainKey* Chain::release_chainkey() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ChainKey* temp = _impl_.chainkey_;
+  _impl_.chainkey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ChainKey* Chain::unsafe_arena_release_chainkey() {
+  // @@protoc_insertion_point(field_release:proto.Chain.chainKey)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ChainKey* temp = _impl_.chainkey_;
+  _impl_.chainkey_ = nullptr;
+  return temp;
+}
+inline ::proto::ChainKey* Chain::_internal_mutable_chainkey() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.chainkey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ChainKey>(GetArenaForAllocation());
+    _impl_.chainkey_ = p;
+  }
+  return _impl_.chainkey_;
+}
+inline ::proto::ChainKey* Chain::mutable_chainkey() {
+  ::proto::ChainKey* _msg = _internal_mutable_chainkey();
+  // @@protoc_insertion_point(field_mutable:proto.Chain.chainKey)
+  return _msg;
+}
+inline void Chain::set_allocated_chainkey(::proto::ChainKey* chainkey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.chainkey_;
+  }
+  if (chainkey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chainkey);
+    if (message_arena != submessage_arena) {
+      chainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, chainkey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.chainkey_ = chainkey;
+  // @@protoc_insertion_point(field_set_allocated:proto.Chain.chainKey)
+}
+
+// repeated .proto.MessageKey messageKeys = 4;
+inline int Chain::_internal_messagekeys_size() const {
+  return _impl_.messagekeys_.size();
+}
+inline int Chain::messagekeys_size() const {
+  return _internal_messagekeys_size();
+}
+inline void Chain::clear_messagekeys() {
+  _impl_.messagekeys_.Clear();
+}
+inline ::proto::MessageKey* Chain::mutable_messagekeys(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Chain.messageKeys)
+  return _impl_.messagekeys_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >*
+Chain::mutable_messagekeys() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Chain.messageKeys)
+  return &_impl_.messagekeys_;
+}
+inline const ::proto::MessageKey& Chain::_internal_messagekeys(int index) const {
+  return _impl_.messagekeys_.Get(index);
+}
+inline const ::proto::MessageKey& Chain::messagekeys(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Chain.messageKeys)
+  return _internal_messagekeys(index);
+}
+inline ::proto::MessageKey* Chain::_internal_add_messagekeys() {
+  return _impl_.messagekeys_.Add();
+}
+inline ::proto::MessageKey* Chain::add_messagekeys() {
+  ::proto::MessageKey* _add = _internal_add_messagekeys();
+  // @@protoc_insertion_point(field_add:proto.Chain.messageKeys)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >&
+Chain::messagekeys() const {
+  // @@protoc_insertion_point(field_list:proto.Chain.messageKeys)
+  return _impl_.messagekeys_;
+}
+
+// -------------------------------------------------------------------
+
+// ChainKey
+
+// optional uint32 index = 1;
+inline bool ChainKey::_internal_has_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ChainKey::has_index() const {
+  return _internal_has_index();
+}
+inline void ChainKey::clear_index() {
+  _impl_.index_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t ChainKey::_internal_index() const {
+  return _impl_.index_;
+}
+inline uint32_t ChainKey::index() const {
+  // @@protoc_insertion_point(field_get:proto.ChainKey.index)
+  return _internal_index();
+}
+inline void ChainKey::_internal_set_index(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.index_ = value;
+}
+inline void ChainKey::set_index(uint32_t value) {
+  _internal_set_index(value);
+  // @@protoc_insertion_point(field_set:proto.ChainKey.index)
+}
+
+// optional bytes key = 2;
+inline bool ChainKey::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ChainKey::has_key() const {
+  return _internal_has_key();
+}
+inline void ChainKey::clear_key() {
+  _impl_.key_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ChainKey::key() const {
+  // @@protoc_insertion_point(field_get:proto.ChainKey.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ChainKey::set_key(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ChainKey.key)
+}
+inline std::string* ChainKey::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.ChainKey.key)
+  return _s;
+}
+inline const std::string& ChainKey::_internal_key() const {
+  return _impl_.key_.Get();
+}
+inline void ChainKey::_internal_set_key(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ChainKey::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ChainKey::release_key() {
+  // @@protoc_insertion_point(field_release:proto.ChainKey.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.key_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ChainKey::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ChainKey.key)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_DNSSource
+
+// optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
+inline bool ClientPayload_DNSSource::_internal_has_dnsmethod() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_DNSSource::has_dnsmethod() const {
+  return _internal_has_dnsmethod();
+}
+inline void ClientPayload_DNSSource::clear_dnsmethod() {
+  _impl_.dnsmethod_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::_internal_dnsmethod() const {
+  return static_cast< ::proto::ClientPayload_DNSSource_DNSResolutionMethod >(_impl_.dnsmethod_);
+}
+inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::dnsmethod() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.dnsMethod)
+  return _internal_dnsmethod();
+}
+inline void ClientPayload_DNSSource::_internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) {
+  assert(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.dnsmethod_ = value;
+}
+inline void ClientPayload_DNSSource::set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) {
+  _internal_set_dnsmethod(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.dnsMethod)
+}
+
+// optional bool appCached = 16;
+inline bool ClientPayload_DNSSource::_internal_has_appcached() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_DNSSource::has_appcached() const {
+  return _internal_has_appcached();
+}
+inline void ClientPayload_DNSSource::clear_appcached() {
+  _impl_.appcached_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool ClientPayload_DNSSource::_internal_appcached() const {
+  return _impl_.appcached_;
+}
+inline bool ClientPayload_DNSSource::appcached() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.appCached)
+  return _internal_appcached();
+}
+inline void ClientPayload_DNSSource::_internal_set_appcached(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.appcached_ = value;
+}
+inline void ClientPayload_DNSSource::set_appcached(bool value) {
+  _internal_set_appcached(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.appCached)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_DevicePairingRegistrationData
+
+// optional bytes eRegid = 1;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eregid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_eregid() const {
+  return _internal_has_eregid();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_eregid() {
+  _impl_.eregid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::eregid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
+  return _internal_eregid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_eregid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.eregid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eregid() {
+  std::string* _s = _internal_mutable_eregid();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eregid() const {
+  return _impl_.eregid_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eregid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.eregid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eregid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.eregid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_eregid() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
+  if (!_internal_has_eregid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.eregid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eregid_.IsDefault()) {
+    _impl_.eregid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eregid(std::string* eregid) {
+  if (eregid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.eregid_.SetAllocated(eregid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eregid_.IsDefault()) {
+    _impl_.eregid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
+}
+
+// optional bytes eKeytype = 2;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_ekeytype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_ekeytype() const {
+  return _internal_has_ekeytype();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_ekeytype() {
+  _impl_.ekeytype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::ekeytype() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
+  return _internal_ekeytype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_ekeytype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.ekeytype_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_ekeytype() {
+  std::string* _s = _internal_mutable_ekeytype();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_ekeytype() const {
+  return _impl_.ekeytype_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_ekeytype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.ekeytype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_ekeytype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.ekeytype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_ekeytype() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
+  if (!_internal_has_ekeytype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.ekeytype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ekeytype_.IsDefault()) {
+    _impl_.ekeytype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_ekeytype(std::string* ekeytype) {
+  if (ekeytype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.ekeytype_.SetAllocated(ekeytype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ekeytype_.IsDefault()) {
+    _impl_.ekeytype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
+}
+
+// optional bytes eIdent = 3;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eident() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_eident() const {
+  return _internal_has_eident();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_eident() {
+  _impl_.eident_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::eident() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
+  return _internal_eident();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_eident(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.eident_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eident() {
+  std::string* _s = _internal_mutable_eident();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eident() const {
+  return _impl_.eident_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eident(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.eident_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eident() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.eident_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_eident() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
+  if (!_internal_has_eident()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.eident_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eident_.IsDefault()) {
+    _impl_.eident_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eident(std::string* eident) {
+  if (eident != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.eident_.SetAllocated(eident, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eident_.IsDefault()) {
+    _impl_.eident_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
+}
+
+// optional bytes eSkeyId = 4;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyid() const {
+  return _internal_has_eskeyid();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyid() {
+  _impl_.eskeyid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
+  return _internal_eskeyid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_eskeyid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.eskeyid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyid() {
+  std::string* _s = _internal_mutable_eskeyid();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyid() const {
+  return _impl_.eskeyid_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.eskeyid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyid() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.eskeyid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyid() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
+  if (!_internal_has_eskeyid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.eskeyid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeyid_.IsDefault()) {
+    _impl_.eskeyid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyid(std::string* eskeyid) {
+  if (eskeyid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.eskeyid_.SetAllocated(eskeyid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeyid_.IsDefault()) {
+    _impl_.eskeyid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
+}
+
+// optional bytes eSkeyVal = 5;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyval() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyval() const {
+  return _internal_has_eskeyval();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyval() {
+  _impl_.eskeyval_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyval() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
+  return _internal_eskeyval();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_eskeyval(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.eskeyval_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyval() {
+  std::string* _s = _internal_mutable_eskeyval();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyval() const {
+  return _impl_.eskeyval_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyval(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.eskeyval_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyval() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.eskeyval_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyval() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
+  if (!_internal_has_eskeyval()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.eskeyval_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeyval_.IsDefault()) {
+    _impl_.eskeyval_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyval(std::string* eskeyval) {
+  if (eskeyval != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.eskeyval_.SetAllocated(eskeyval, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeyval_.IsDefault()) {
+    _impl_.eskeyval_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
+}
+
+// optional bytes eSkeySig = 6;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeysig() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_eskeysig() const {
+  return _internal_has_eskeysig();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_eskeysig() {
+  _impl_.eskeysig_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeysig() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
+  return _internal_eskeysig();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_eskeysig(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.eskeysig_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeysig() {
+  std::string* _s = _internal_mutable_eskeysig();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeysig() const {
+  return _impl_.eskeysig_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeysig(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.eskeysig_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeysig() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.eskeysig_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeysig() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
+  if (!_internal_has_eskeysig()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.eskeysig_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeysig_.IsDefault()) {
+    _impl_.eskeysig_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeysig(std::string* eskeysig) {
+  if (eskeysig != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.eskeysig_.SetAllocated(eskeysig, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.eskeysig_.IsDefault()) {
+    _impl_.eskeysig_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
+}
+
+// optional bytes buildHash = 7;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_buildhash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_buildhash() const {
+  return _internal_has_buildhash();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_buildhash() {
+  _impl_.buildhash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::buildhash() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
+  return _internal_buildhash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_buildhash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.buildhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_buildhash() {
+  std::string* _s = _internal_mutable_buildhash();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_buildhash() const {
+  return _impl_.buildhash_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_buildhash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.buildhash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_buildhash() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.buildhash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_buildhash() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
+  if (!_internal_has_buildhash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.buildhash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buildhash_.IsDefault()) {
+    _impl_.buildhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_buildhash(std::string* buildhash) {
+  if (buildhash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.buildhash_.SetAllocated(buildhash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buildhash_.IsDefault()) {
+    _impl_.buildhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
+}
+
+// optional bytes deviceProps = 8;
+inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_deviceprops() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientPayload_DevicePairingRegistrationData::has_deviceprops() const {
+  return _internal_has_deviceprops();
+}
+inline void ClientPayload_DevicePairingRegistrationData::clear_deviceprops() {
+  _impl_.deviceprops_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::deviceprops() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
+  return _internal_deviceprops();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_DevicePairingRegistrationData::set_deviceprops(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.deviceprops_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_deviceprops() {
+  std::string* _s = _internal_mutable_deviceprops();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
+  return _s;
+}
+inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_deviceprops() const {
+  return _impl_.deviceprops_.Get();
+}
+inline void ClientPayload_DevicePairingRegistrationData::_internal_set_deviceprops(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.deviceprops_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_deviceprops() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.deviceprops_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_DevicePairingRegistrationData::release_deviceprops() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
+  if (!_internal_has_deviceprops()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.deviceprops_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deviceprops_.IsDefault()) {
+    _impl_.deviceprops_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_DevicePairingRegistrationData::set_allocated_deviceprops(std::string* deviceprops) {
+  if (deviceprops != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.deviceprops_.SetAllocated(deviceprops, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deviceprops_.IsDefault()) {
+    _impl_.deviceprops_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_UserAgent_AppVersion
+
+// optional uint32 primary = 1;
+inline bool ClientPayload_UserAgent_AppVersion::_internal_has_primary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent_AppVersion::has_primary() const {
+  return _internal_has_primary();
+}
+inline void ClientPayload_UserAgent_AppVersion::clear_primary() {
+  _impl_.primary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_primary() const {
+  return _impl_.primary_;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::primary() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.primary)
+  return _internal_primary();
+}
+inline void ClientPayload_UserAgent_AppVersion::_internal_set_primary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.primary_ = value;
+}
+inline void ClientPayload_UserAgent_AppVersion::set_primary(uint32_t value) {
+  _internal_set_primary(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.primary)
+}
+
+// optional uint32 secondary = 2;
+inline bool ClientPayload_UserAgent_AppVersion::_internal_has_secondary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent_AppVersion::has_secondary() const {
+  return _internal_has_secondary();
+}
+inline void ClientPayload_UserAgent_AppVersion::clear_secondary() {
+  _impl_.secondary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_secondary() const {
+  return _impl_.secondary_;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::secondary() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.secondary)
+  return _internal_secondary();
+}
+inline void ClientPayload_UserAgent_AppVersion::_internal_set_secondary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.secondary_ = value;
+}
+inline void ClientPayload_UserAgent_AppVersion::set_secondary(uint32_t value) {
+  _internal_set_secondary(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.secondary)
+}
+
+// optional uint32 tertiary = 3;
+inline bool ClientPayload_UserAgent_AppVersion::_internal_has_tertiary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent_AppVersion::has_tertiary() const {
+  return _internal_has_tertiary();
+}
+inline void ClientPayload_UserAgent_AppVersion::clear_tertiary() {
+  _impl_.tertiary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_tertiary() const {
+  return _impl_.tertiary_;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::tertiary() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.tertiary)
+  return _internal_tertiary();
+}
+inline void ClientPayload_UserAgent_AppVersion::_internal_set_tertiary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.tertiary_ = value;
+}
+inline void ClientPayload_UserAgent_AppVersion::set_tertiary(uint32_t value) {
+  _internal_set_tertiary(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.tertiary)
+}
+
+// optional uint32 quaternary = 4;
+inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quaternary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent_AppVersion::has_quaternary() const {
+  return _internal_has_quaternary();
+}
+inline void ClientPayload_UserAgent_AppVersion::clear_quaternary() {
+  _impl_.quaternary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quaternary() const {
+  return _impl_.quaternary_;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::quaternary() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quaternary)
+  return _internal_quaternary();
+}
+inline void ClientPayload_UserAgent_AppVersion::_internal_set_quaternary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.quaternary_ = value;
+}
+inline void ClientPayload_UserAgent_AppVersion::set_quaternary(uint32_t value) {
+  _internal_set_quaternary(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quaternary)
+}
+
+// optional uint32 quinary = 5;
+inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quinary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent_AppVersion::has_quinary() const {
+  return _internal_has_quinary();
+}
+inline void ClientPayload_UserAgent_AppVersion::clear_quinary() {
+  _impl_.quinary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quinary() const {
+  return _impl_.quinary_;
+}
+inline uint32_t ClientPayload_UserAgent_AppVersion::quinary() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quinary)
+  return _internal_quinary();
+}
+inline void ClientPayload_UserAgent_AppVersion::_internal_set_quinary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.quinary_ = value;
+}
+inline void ClientPayload_UserAgent_AppVersion::set_quinary(uint32_t value) {
+  _internal_set_quinary(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quinary)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_UserAgent
+
+// optional .proto.ClientPayload.UserAgent.Platform platform = 1;
+inline bool ClientPayload_UserAgent::_internal_has_platform() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_platform() const {
+  return _internal_has_platform();
+}
+inline void ClientPayload_UserAgent::clear_platform() {
+  _impl_.platform_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::_internal_platform() const {
+  return static_cast< ::proto::ClientPayload_UserAgent_Platform >(_impl_.platform_);
+}
+inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::platform() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.platform)
+  return _internal_platform();
+}
+inline void ClientPayload_UserAgent::_internal_set_platform(::proto::ClientPayload_UserAgent_Platform value) {
+  assert(::proto::ClientPayload_UserAgent_Platform_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.platform_ = value;
+}
+inline void ClientPayload_UserAgent::set_platform(::proto::ClientPayload_UserAgent_Platform value) {
+  _internal_set_platform(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.platform)
+}
+
+// optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
+inline bool ClientPayload_UserAgent::_internal_has_appversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.appversion_ != nullptr);
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_appversion() const {
+  return _internal_has_appversion();
+}
+inline void ClientPayload_UserAgent::clear_appversion() {
+  if (_impl_.appversion_ != nullptr) _impl_.appversion_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::_internal_appversion() const {
+  const ::proto::ClientPayload_UserAgent_AppVersion* p = _impl_.appversion_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_UserAgent_AppVersion&>(
+      ::proto::_ClientPayload_UserAgent_AppVersion_default_instance_);
+}
+inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::appversion() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.appVersion)
+  return _internal_appversion();
+}
+inline void ClientPayload_UserAgent::unsafe_arena_set_allocated_appversion(
+    ::proto::ClientPayload_UserAgent_AppVersion* appversion) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appversion_);
+  }
+  _impl_.appversion_ = appversion;
+  if (appversion) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.UserAgent.appVersion)
+}
+inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::release_appversion() {
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_;
+  _impl_.appversion_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::unsafe_arena_release_appversion() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.appVersion)
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_;
+  _impl_.appversion_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::_internal_mutable_appversion() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  if (_impl_.appversion_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(GetArenaForAllocation());
+    _impl_.appversion_ = p;
+  }
+  return _impl_.appversion_;
+}
+inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::mutable_appversion() {
+  ::proto::ClientPayload_UserAgent_AppVersion* _msg = _internal_mutable_appversion();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.appVersion)
+  return _msg;
+}
+inline void ClientPayload_UserAgent::set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.appversion_;
+  }
+  if (appversion) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appversion);
+    if (message_arena != submessage_arena) {
+      appversion = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, appversion, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.appversion_ = appversion;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.appVersion)
+}
+
+// optional string mcc = 3;
+inline bool ClientPayload_UserAgent::_internal_has_mcc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_mcc() const {
+  return _internal_has_mcc();
+}
+inline void ClientPayload_UserAgent::clear_mcc() {
+  _impl_.mcc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPayload_UserAgent::mcc() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mcc)
+  return _internal_mcc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_mcc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.mcc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mcc)
+}
+inline std::string* ClientPayload_UserAgent::mutable_mcc() {
+  std::string* _s = _internal_mutable_mcc();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mcc)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_mcc() const {
+  return _impl_.mcc_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_mcc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.mcc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_mcc() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.mcc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_mcc() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mcc)
+  if (!_internal_has_mcc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.mcc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mcc_.IsDefault()) {
+    _impl_.mcc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_mcc(std::string* mcc) {
+  if (mcc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.mcc_.SetAllocated(mcc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mcc_.IsDefault()) {
+    _impl_.mcc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mcc)
+}
+
+// optional string mnc = 4;
+inline bool ClientPayload_UserAgent::_internal_has_mnc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_mnc() const {
+  return _internal_has_mnc();
+}
+inline void ClientPayload_UserAgent::clear_mnc() {
+  _impl_.mnc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPayload_UserAgent::mnc() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mnc)
+  return _internal_mnc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_mnc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mnc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mnc)
+}
+inline std::string* ClientPayload_UserAgent::mutable_mnc() {
+  std::string* _s = _internal_mutable_mnc();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mnc)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_mnc() const {
+  return _impl_.mnc_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_mnc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mnc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_mnc() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mnc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_mnc() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mnc)
+  if (!_internal_has_mnc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mnc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mnc_.IsDefault()) {
+    _impl_.mnc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_mnc(std::string* mnc) {
+  if (mnc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mnc_.SetAllocated(mnc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mnc_.IsDefault()) {
+    _impl_.mnc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mnc)
+}
+
+// optional string osVersion = 5;
+inline bool ClientPayload_UserAgent::_internal_has_osversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_osversion() const {
+  return _internal_has_osversion();
+}
+inline void ClientPayload_UserAgent::clear_osversion() {
+  _impl_.osversion_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientPayload_UserAgent::osversion() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osVersion)
+  return _internal_osversion();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_osversion(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.osversion_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osVersion)
+}
+inline std::string* ClientPayload_UserAgent::mutable_osversion() {
+  std::string* _s = _internal_mutable_osversion();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osVersion)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_osversion() const {
+  return _impl_.osversion_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_osversion(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.osversion_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_osversion() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.osversion_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_osversion() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osVersion)
+  if (!_internal_has_osversion()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.osversion_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.osversion_.IsDefault()) {
+    _impl_.osversion_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_osversion(std::string* osversion) {
+  if (osversion != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.osversion_.SetAllocated(osversion, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.osversion_.IsDefault()) {
+    _impl_.osversion_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osVersion)
+}
+
+// optional string manufacturer = 6;
+inline bool ClientPayload_UserAgent::_internal_has_manufacturer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_manufacturer() const {
+  return _internal_has_manufacturer();
+}
+inline void ClientPayload_UserAgent::clear_manufacturer() {
+  _impl_.manufacturer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientPayload_UserAgent::manufacturer() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.manufacturer)
+}
+inline std::string* ClientPayload_UserAgent::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.manufacturer)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_manufacturer() const {
+  return _impl_.manufacturer_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_manufacturer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.manufacturer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_manufacturer() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.manufacturer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.manufacturer)
+  if (!_internal_has_manufacturer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.manufacturer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.manufacturer_.IsDefault()) {
+    _impl_.manufacturer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.manufacturer_.IsDefault()) {
+    _impl_.manufacturer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.manufacturer)
+}
+
+// optional string device = 7;
+inline bool ClientPayload_UserAgent::_internal_has_device() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_device() const {
+  return _internal_has_device();
+}
+inline void ClientPayload_UserAgent::clear_device() {
+  _impl_.device_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientPayload_UserAgent::device() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_device(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.device)
+}
+inline std::string* ClientPayload_UserAgent::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.device)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_device(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_device() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_device() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.device)
+  if (!_internal_has_device()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.device_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.device)
+}
+
+// optional string osBuildNumber = 8;
+inline bool ClientPayload_UserAgent::_internal_has_osbuildnumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_osbuildnumber() const {
+  return _internal_has_osbuildnumber();
+}
+inline void ClientPayload_UserAgent::clear_osbuildnumber() {
+  _impl_.osbuildnumber_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& ClientPayload_UserAgent::osbuildnumber() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osBuildNumber)
+  return _internal_osbuildnumber();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_osbuildnumber(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.osbuildnumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osBuildNumber)
+}
+inline std::string* ClientPayload_UserAgent::mutable_osbuildnumber() {
+  std::string* _s = _internal_mutable_osbuildnumber();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osBuildNumber)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_osbuildnumber() const {
+  return _impl_.osbuildnumber_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_osbuildnumber(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.osbuildnumber_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_osbuildnumber() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.osbuildnumber_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_osbuildnumber() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osBuildNumber)
+  if (!_internal_has_osbuildnumber()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.osbuildnumber_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.osbuildnumber_.IsDefault()) {
+    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_osbuildnumber(std::string* osbuildnumber) {
+  if (osbuildnumber != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.osbuildnumber_.SetAllocated(osbuildnumber, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.osbuildnumber_.IsDefault()) {
+    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osBuildNumber)
+}
+
+// optional string phoneId = 9;
+inline bool ClientPayload_UserAgent::_internal_has_phoneid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_phoneid() const {
+  return _internal_has_phoneid();
+}
+inline void ClientPayload_UserAgent::clear_phoneid() {
+  _impl_.phoneid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& ClientPayload_UserAgent::phoneid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.phoneId)
+  return _internal_phoneid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_phoneid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.phoneid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.phoneId)
+}
+inline std::string* ClientPayload_UserAgent::mutable_phoneid() {
+  std::string* _s = _internal_mutable_phoneid();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.phoneId)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_phoneid() const {
+  return _impl_.phoneid_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_phoneid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.phoneid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_phoneid() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.phoneid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_phoneid() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.phoneId)
+  if (!_internal_has_phoneid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.phoneid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phoneid_.IsDefault()) {
+    _impl_.phoneid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_phoneid(std::string* phoneid) {
+  if (phoneid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.phoneid_.SetAllocated(phoneid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phoneid_.IsDefault()) {
+    _impl_.phoneid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.phoneId)
+}
+
+// optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
+inline bool ClientPayload_UserAgent::_internal_has_releasechannel() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_releasechannel() const {
+  return _internal_has_releasechannel();
+}
+inline void ClientPayload_UserAgent::clear_releasechannel() {
+  _impl_.releasechannel_ = 0;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::_internal_releasechannel() const {
+  return static_cast< ::proto::ClientPayload_UserAgent_ReleaseChannel >(_impl_.releasechannel_);
+}
+inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::releasechannel() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.releaseChannel)
+  return _internal_releasechannel();
+}
+inline void ClientPayload_UserAgent::_internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) {
+  assert(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.releasechannel_ = value;
+}
+inline void ClientPayload_UserAgent::set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) {
+  _internal_set_releasechannel(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.releaseChannel)
+}
+
+// optional string localeLanguageIso6391 = 11;
+inline bool ClientPayload_UserAgent::_internal_has_localelanguageiso6391() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_localelanguageiso6391() const {
+  return _internal_has_localelanguageiso6391();
+}
+inline void ClientPayload_UserAgent::clear_localelanguageiso6391() {
+  _impl_.localelanguageiso6391_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& ClientPayload_UserAgent::localelanguageiso6391() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeLanguageIso6391)
+  return _internal_localelanguageiso6391();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_localelanguageiso6391(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.localelanguageiso6391_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeLanguageIso6391)
+}
+inline std::string* ClientPayload_UserAgent::mutable_localelanguageiso6391() {
+  std::string* _s = _internal_mutable_localelanguageiso6391();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeLanguageIso6391)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_localelanguageiso6391() const {
+  return _impl_.localelanguageiso6391_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_localelanguageiso6391(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.localelanguageiso6391_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_localelanguageiso6391() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.localelanguageiso6391_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_localelanguageiso6391() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeLanguageIso6391)
+  if (!_internal_has_localelanguageiso6391()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.localelanguageiso6391_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localelanguageiso6391_.IsDefault()) {
+    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_localelanguageiso6391(std::string* localelanguageiso6391) {
+  if (localelanguageiso6391 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.localelanguageiso6391_.SetAllocated(localelanguageiso6391, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localelanguageiso6391_.IsDefault()) {
+    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeLanguageIso6391)
+}
+
+// optional string localeCountryIso31661Alpha2 = 12;
+inline bool ClientPayload_UserAgent::_internal_has_localecountryiso31661alpha2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_localecountryiso31661alpha2() const {
+  return _internal_has_localecountryiso31661alpha2();
+}
+inline void ClientPayload_UserAgent::clear_localecountryiso31661alpha2() {
+  _impl_.localecountryiso31661alpha2_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& ClientPayload_UserAgent::localecountryiso31661alpha2() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
+  return _internal_localecountryiso31661alpha2();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.localecountryiso31661alpha2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
+}
+inline std::string* ClientPayload_UserAgent::mutable_localecountryiso31661alpha2() {
+  std::string* _s = _internal_mutable_localecountryiso31661alpha2();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_localecountryiso31661alpha2() const {
+  return _impl_.localecountryiso31661alpha2_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_localecountryiso31661alpha2(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.localecountryiso31661alpha2_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_localecountryiso31661alpha2() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.localecountryiso31661alpha2_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_localecountryiso31661alpha2() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
+  if (!_internal_has_localecountryiso31661alpha2()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.localecountryiso31661alpha2_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localecountryiso31661alpha2_.IsDefault()) {
+    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2) {
+  if (localecountryiso31661alpha2 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.localecountryiso31661alpha2_.SetAllocated(localecountryiso31661alpha2, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localecountryiso31661alpha2_.IsDefault()) {
+    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
+}
+
+// optional string deviceBoard = 13;
+inline bool ClientPayload_UserAgent::_internal_has_deviceboard() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientPayload_UserAgent::has_deviceboard() const {
+  return _internal_has_deviceboard();
+}
+inline void ClientPayload_UserAgent::clear_deviceboard() {
+  _impl_.deviceboard_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& ClientPayload_UserAgent::deviceboard() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.deviceBoard)
+  return _internal_deviceboard();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_UserAgent::set_deviceboard(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.deviceboard_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.deviceBoard)
+}
+inline std::string* ClientPayload_UserAgent::mutable_deviceboard() {
+  std::string* _s = _internal_mutable_deviceboard();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.deviceBoard)
+  return _s;
+}
+inline const std::string& ClientPayload_UserAgent::_internal_deviceboard() const {
+  return _impl_.deviceboard_.Get();
+}
+inline void ClientPayload_UserAgent::_internal_set_deviceboard(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.deviceboard_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::_internal_mutable_deviceboard() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.deviceboard_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_UserAgent::release_deviceboard() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.deviceBoard)
+  if (!_internal_has_deviceboard()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.deviceboard_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deviceboard_.IsDefault()) {
+    _impl_.deviceboard_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_UserAgent::set_allocated_deviceboard(std::string* deviceboard) {
+  if (deviceboard != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.deviceboard_.SetAllocated(deviceboard, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deviceboard_.IsDefault()) {
+    _impl_.deviceboard_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.deviceBoard)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_WebInfo_WebdPayload
+
+// optional bool usesParticipantInKey = 1;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_usesparticipantinkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_usesparticipantinkey() const {
+  return _internal_has_usesparticipantinkey();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_usesparticipantinkey() {
+  _impl_.usesparticipantinkey_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_usesparticipantinkey() const {
+  return _impl_.usesparticipantinkey_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::usesparticipantinkey() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey)
+  return _internal_usesparticipantinkey();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_usesparticipantinkey(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.usesparticipantinkey_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_usesparticipantinkey(bool value) {
+  _internal_set_usesparticipantinkey(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey)
+}
+
+// optional bool supportsStarredMessages = 2;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsstarredmessages() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportsstarredmessages() const {
+  return _internal_has_supportsstarredmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportsstarredmessages() {
+  _impl_.supportsstarredmessages_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsstarredmessages() const {
+  return _impl_.supportsstarredmessages_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportsstarredmessages() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages)
+  return _internal_supportsstarredmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsstarredmessages(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.supportsstarredmessages_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportsstarredmessages(bool value) {
+  _internal_set_supportsstarredmessages(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages)
+}
+
+// optional bool supportsDocumentMessages = 3;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsdocumentmessages() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportsdocumentmessages() const {
+  return _internal_has_supportsdocumentmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportsdocumentmessages() {
+  _impl_.supportsdocumentmessages_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsdocumentmessages() const {
+  return _impl_.supportsdocumentmessages_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportsdocumentmessages() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages)
+  return _internal_supportsdocumentmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsdocumentmessages(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.supportsdocumentmessages_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportsdocumentmessages(bool value) {
+  _internal_set_supportsdocumentmessages(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages)
+}
+
+// optional bool supportsUrlMessages = 4;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsurlmessages() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportsurlmessages() const {
+  return _internal_has_supportsurlmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportsurlmessages() {
+  _impl_.supportsurlmessages_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsurlmessages() const {
+  return _impl_.supportsurlmessages_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportsurlmessages() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages)
+  return _internal_supportsurlmessages();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsurlmessages(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.supportsurlmessages_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportsurlmessages(bool value) {
+  _internal_set_supportsurlmessages(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages)
+}
+
+// optional bool supportsMediaRetry = 5;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsmediaretry() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportsmediaretry() const {
+  return _internal_has_supportsmediaretry();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportsmediaretry() {
+  _impl_.supportsmediaretry_ = false;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsmediaretry() const {
+  return _impl_.supportsmediaretry_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportsmediaretry() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry)
+  return _internal_supportsmediaretry();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsmediaretry(bool value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.supportsmediaretry_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportsmediaretry(bool value) {
+  _internal_set_supportsmediaretry(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry)
+}
+
+// optional bool supportsE2EImage = 6;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eimage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eimage() const {
+  return _internal_has_supportse2eimage();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eimage() {
+  _impl_.supportse2eimage_ = false;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eimage() const {
+  return _impl_.supportse2eimage_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportse2eimage() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage)
+  return _internal_supportse2eimage();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eimage(bool value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.supportse2eimage_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eimage(bool value) {
+  _internal_set_supportse2eimage(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage)
+}
+
+// optional bool supportsE2EVideo = 7;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2evideo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2evideo() const {
+  return _internal_has_supportse2evideo();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2evideo() {
+  _impl_.supportse2evideo_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2evideo() const {
+  return _impl_.supportse2evideo_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportse2evideo() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo)
+  return _internal_supportse2evideo();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2evideo(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.supportse2evideo_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportse2evideo(bool value) {
+  _internal_set_supportse2evideo(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo)
+}
+
+// optional bool supportsE2EAudio = 8;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eaudio() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eaudio() const {
+  return _internal_has_supportse2eaudio();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eaudio() {
+  _impl_.supportse2eaudio_ = false;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eaudio() const {
+  return _impl_.supportse2eaudio_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportse2eaudio() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio)
+  return _internal_supportse2eaudio();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eaudio(bool value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.supportse2eaudio_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eaudio(bool value) {
+  _internal_set_supportse2eaudio(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio)
+}
+
+// optional bool supportsE2EDocument = 9;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2edocument() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2edocument() const {
+  return _internal_has_supportse2edocument();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2edocument() {
+  _impl_.supportse2edocument_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2edocument() const {
+  return _impl_.supportse2edocument_;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::supportse2edocument() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument)
+  return _internal_supportse2edocument();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2edocument(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.supportse2edocument_ = value;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_supportse2edocument(bool value) {
+  _internal_set_supportse2edocument(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument)
+}
+
+// optional string documentTypes = 10;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_documenttypes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_documenttypes() const {
+  return _internal_has_documenttypes();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_documenttypes() {
+  _impl_.documenttypes_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPayload_WebInfo_WebdPayload::documenttypes() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
+  return _internal_documenttypes();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_WebInfo_WebdPayload::set_documenttypes(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.documenttypes_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_documenttypes() {
+  std::string* _s = _internal_mutable_documenttypes();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
+  return _s;
+}
+inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_documenttypes() const {
+  return _impl_.documenttypes_.Get();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_documenttypes(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.documenttypes_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_documenttypes() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.documenttypes_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::release_documenttypes() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
+  if (!_internal_has_documenttypes()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.documenttypes_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.documenttypes_.IsDefault()) {
+    _impl_.documenttypes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_allocated_documenttypes(std::string* documenttypes) {
+  if (documenttypes != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.documenttypes_.SetAllocated(documenttypes, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.documenttypes_.IsDefault()) {
+    _impl_.documenttypes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
+}
+
+// optional bytes features = 11;
+inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_features() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo_WebdPayload::has_features() const {
+  return _internal_has_features();
+}
+inline void ClientPayload_WebInfo_WebdPayload::clear_features() {
+  _impl_.features_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPayload_WebInfo_WebdPayload::features() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.features)
+  return _internal_features();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_WebInfo_WebdPayload::set_features(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.features_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.features)
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_features() {
+  std::string* _s = _internal_mutable_features();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.features)
+  return _s;
+}
+inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_features() const {
+  return _impl_.features_.Get();
+}
+inline void ClientPayload_WebInfo_WebdPayload::_internal_set_features(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.features_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_features() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.features_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo_WebdPayload::release_features() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.features)
+  if (!_internal_has_features()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.features_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.features_.IsDefault()) {
+    _impl_.features_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_WebInfo_WebdPayload::set_allocated_features(std::string* features) {
+  if (features != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.features_.SetAllocated(features, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.features_.IsDefault()) {
+    _impl_.features_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.features)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload_WebInfo
+
+// optional string refToken = 1;
+inline bool ClientPayload_WebInfo::_internal_has_reftoken() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo::has_reftoken() const {
+  return _internal_has_reftoken();
+}
+inline void ClientPayload_WebInfo::clear_reftoken() {
+  _impl_.reftoken_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPayload_WebInfo::reftoken() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.refToken)
+  return _internal_reftoken();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_WebInfo::set_reftoken(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.reftoken_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.refToken)
+}
+inline std::string* ClientPayload_WebInfo::mutable_reftoken() {
+  std::string* _s = _internal_mutable_reftoken();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.refToken)
+  return _s;
+}
+inline const std::string& ClientPayload_WebInfo::_internal_reftoken() const {
+  return _impl_.reftoken_.Get();
+}
+inline void ClientPayload_WebInfo::_internal_set_reftoken(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.reftoken_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo::_internal_mutable_reftoken() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.reftoken_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo::release_reftoken() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.refToken)
+  if (!_internal_has_reftoken()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.reftoken_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.reftoken_.IsDefault()) {
+    _impl_.reftoken_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_WebInfo::set_allocated_reftoken(std::string* reftoken) {
+  if (reftoken != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.reftoken_.SetAllocated(reftoken, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.reftoken_.IsDefault()) {
+    _impl_.reftoken_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.refToken)
+}
+
+// optional string version = 2;
+inline bool ClientPayload_WebInfo::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo::has_version() const {
+  return _internal_has_version();
+}
+inline void ClientPayload_WebInfo::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPayload_WebInfo::version() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload_WebInfo::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.version)
+}
+inline std::string* ClientPayload_WebInfo::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.version)
+  return _s;
+}
+inline const std::string& ClientPayload_WebInfo::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void ClientPayload_WebInfo::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload_WebInfo::release_version() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload_WebInfo::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.version)
+}
+
+// optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
+inline bool ClientPayload_WebInfo::_internal_has_webdpayload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.webdpayload_ != nullptr);
+  return value;
+}
+inline bool ClientPayload_WebInfo::has_webdpayload() const {
+  return _internal_has_webdpayload();
+}
+inline void ClientPayload_WebInfo::clear_webdpayload() {
+  if (_impl_.webdpayload_ != nullptr) _impl_.webdpayload_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::_internal_webdpayload() const {
+  const ::proto::ClientPayload_WebInfo_WebdPayload* p = _impl_.webdpayload_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_WebInfo_WebdPayload&>(
+      ::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_);
+}
+inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::webdpayload() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webdPayload)
+  return _internal_webdpayload();
+}
+inline void ClientPayload_WebInfo::unsafe_arena_set_allocated_webdpayload(
+    ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webdpayload_);
+  }
+  _impl_.webdpayload_ = webdpayload;
+  if (webdpayload) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.WebInfo.webdPayload)
+}
+inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::release_webdpayload() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_;
+  _impl_.webdpayload_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::unsafe_arena_release_webdpayload() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.webdPayload)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_;
+  _impl_.webdpayload_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::_internal_mutable_webdpayload() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.webdpayload_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(GetArenaForAllocation());
+    _impl_.webdpayload_ = p;
+  }
+  return _impl_.webdpayload_;
+}
+inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::mutable_webdpayload() {
+  ::proto::ClientPayload_WebInfo_WebdPayload* _msg = _internal_mutable_webdpayload();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.webdPayload)
+  return _msg;
+}
+inline void ClientPayload_WebInfo::set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.webdpayload_;
+  }
+  if (webdpayload) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webdpayload);
+    if (message_arena != submessage_arena) {
+      webdpayload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, webdpayload, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.webdpayload_ = webdpayload;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.webdPayload)
+}
+
+// optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
+inline bool ClientPayload_WebInfo::_internal_has_websubplatform() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload_WebInfo::has_websubplatform() const {
+  return _internal_has_websubplatform();
+}
+inline void ClientPayload_WebInfo::clear_websubplatform() {
+  _impl_.websubplatform_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::_internal_websubplatform() const {
+  return static_cast< ::proto::ClientPayload_WebInfo_WebSubPlatform >(_impl_.websubplatform_);
+}
+inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::websubplatform() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webSubPlatform)
+  return _internal_websubplatform();
+}
+inline void ClientPayload_WebInfo::_internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) {
+  assert(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.websubplatform_ = value;
+}
+inline void ClientPayload_WebInfo::set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) {
+  _internal_set_websubplatform(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.webSubPlatform)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPayload
+
+// optional uint64 username = 1;
+inline bool ClientPayload::_internal_has_username() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_username() const {
+  return _internal_has_username();
+}
+inline void ClientPayload::clear_username() {
+  _impl_.username_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint64_t ClientPayload::_internal_username() const {
+  return _impl_.username_;
+}
+inline uint64_t ClientPayload::username() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.username)
+  return _internal_username();
+}
+inline void ClientPayload::_internal_set_username(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.username_ = value;
+}
+inline void ClientPayload::set_username(uint64_t value) {
+  _internal_set_username(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.username)
+}
+
+// optional bool passive = 3;
+inline bool ClientPayload::_internal_has_passive() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_passive() const {
+  return _internal_has_passive();
+}
+inline void ClientPayload::clear_passive() {
+  _impl_.passive_ = false;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline bool ClientPayload::_internal_passive() const {
+  return _impl_.passive_;
+}
+inline bool ClientPayload::passive() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.passive)
+  return _internal_passive();
+}
+inline void ClientPayload::_internal_set_passive(bool value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.passive_ = value;
+}
+inline void ClientPayload::set_passive(bool value) {
+  _internal_set_passive(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.passive)
+}
+
+// optional .proto.ClientPayload.UserAgent userAgent = 5;
+inline bool ClientPayload::_internal_has_useragent() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.useragent_ != nullptr);
+  return value;
+}
+inline bool ClientPayload::has_useragent() const {
+  return _internal_has_useragent();
+}
+inline void ClientPayload::clear_useragent() {
+  if (_impl_.useragent_ != nullptr) _impl_.useragent_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ClientPayload_UserAgent& ClientPayload::_internal_useragent() const {
+  const ::proto::ClientPayload_UserAgent* p = _impl_.useragent_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_UserAgent&>(
+      ::proto::_ClientPayload_UserAgent_default_instance_);
+}
+inline const ::proto::ClientPayload_UserAgent& ClientPayload::useragent() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.userAgent)
+  return _internal_useragent();
+}
+inline void ClientPayload::unsafe_arena_set_allocated_useragent(
+    ::proto::ClientPayload_UserAgent* useragent) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.useragent_);
+  }
+  _impl_.useragent_ = useragent;
+  if (useragent) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.userAgent)
+}
+inline ::proto::ClientPayload_UserAgent* ClientPayload::release_useragent() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_;
+  _impl_.useragent_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_UserAgent* ClientPayload::unsafe_arena_release_useragent() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.userAgent)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_;
+  _impl_.useragent_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_UserAgent* ClientPayload::_internal_mutable_useragent() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.useragent_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent>(GetArenaForAllocation());
+    _impl_.useragent_ = p;
+  }
+  return _impl_.useragent_;
+}
+inline ::proto::ClientPayload_UserAgent* ClientPayload::mutable_useragent() {
+  ::proto::ClientPayload_UserAgent* _msg = _internal_mutable_useragent();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.userAgent)
+  return _msg;
+}
+inline void ClientPayload::set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.useragent_;
+  }
+  if (useragent) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(useragent);
+    if (message_arena != submessage_arena) {
+      useragent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, useragent, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.useragent_ = useragent;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.userAgent)
+}
+
+// optional .proto.ClientPayload.WebInfo webInfo = 6;
+inline bool ClientPayload::_internal_has_webinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.webinfo_ != nullptr);
+  return value;
+}
+inline bool ClientPayload::has_webinfo() const {
+  return _internal_has_webinfo();
+}
+inline void ClientPayload::clear_webinfo() {
+  if (_impl_.webinfo_ != nullptr) _impl_.webinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::ClientPayload_WebInfo& ClientPayload::_internal_webinfo() const {
+  const ::proto::ClientPayload_WebInfo* p = _impl_.webinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_WebInfo&>(
+      ::proto::_ClientPayload_WebInfo_default_instance_);
+}
+inline const ::proto::ClientPayload_WebInfo& ClientPayload::webinfo() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.webInfo)
+  return _internal_webinfo();
+}
+inline void ClientPayload::unsafe_arena_set_allocated_webinfo(
+    ::proto::ClientPayload_WebInfo* webinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webinfo_);
+  }
+  _impl_.webinfo_ = webinfo;
+  if (webinfo) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.webInfo)
+}
+inline ::proto::ClientPayload_WebInfo* ClientPayload::release_webinfo() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_;
+  _impl_.webinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_WebInfo* ClientPayload::unsafe_arena_release_webinfo() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.webInfo)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_;
+  _impl_.webinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_WebInfo* ClientPayload::_internal_mutable_webinfo() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.webinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo>(GetArenaForAllocation());
+    _impl_.webinfo_ = p;
+  }
+  return _impl_.webinfo_;
+}
+inline ::proto::ClientPayload_WebInfo* ClientPayload::mutable_webinfo() {
+  ::proto::ClientPayload_WebInfo* _msg = _internal_mutable_webinfo();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.webInfo)
+  return _msg;
+}
+inline void ClientPayload::set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.webinfo_;
+  }
+  if (webinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webinfo);
+    if (message_arena != submessage_arena) {
+      webinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, webinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.webinfo_ = webinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.webInfo)
+}
+
+// optional string pushName = 7;
+inline bool ClientPayload::_internal_has_pushname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_pushname() const {
+  return _internal_has_pushname();
+}
+inline void ClientPayload::clear_pushname() {
+  _impl_.pushname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPayload::pushname() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.pushName)
+  return _internal_pushname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload::set_pushname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.pushName)
+}
+inline std::string* ClientPayload::mutable_pushname() {
+  std::string* _s = _internal_mutable_pushname();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.pushName)
+  return _s;
+}
+inline const std::string& ClientPayload::_internal_pushname() const {
+  return _impl_.pushname_.Get();
+}
+inline void ClientPayload::_internal_set_pushname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.pushname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload::_internal_mutable_pushname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.pushname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload::release_pushname() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.pushName)
+  if (!_internal_has_pushname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.pushname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload::set_allocated_pushname(std::string* pushname) {
+  if (pushname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.pushName)
+}
+
+// optional sfixed32 sessionId = 9;
+inline bool ClientPayload::_internal_has_sessionid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_sessionid() const {
+  return _internal_has_sessionid();
+}
+inline void ClientPayload::clear_sessionid() {
+  _impl_.sessionid_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline int32_t ClientPayload::_internal_sessionid() const {
+  return _impl_.sessionid_;
+}
+inline int32_t ClientPayload::sessionid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.sessionId)
+  return _internal_sessionid();
+}
+inline void ClientPayload::_internal_set_sessionid(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.sessionid_ = value;
+}
+inline void ClientPayload::set_sessionid(int32_t value) {
+  _internal_set_sessionid(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.sessionId)
+}
+
+// optional bool shortConnect = 10;
+inline bool ClientPayload::_internal_has_shortconnect() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_shortconnect() const {
+  return _internal_has_shortconnect();
+}
+inline void ClientPayload::clear_shortconnect() {
+  _impl_.shortconnect_ = false;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline bool ClientPayload::_internal_shortconnect() const {
+  return _impl_.shortconnect_;
+}
+inline bool ClientPayload::shortconnect() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.shortConnect)
+  return _internal_shortconnect();
+}
+inline void ClientPayload::_internal_set_shortconnect(bool value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.shortconnect_ = value;
+}
+inline void ClientPayload::set_shortconnect(bool value) {
+  _internal_set_shortconnect(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.shortConnect)
+}
+
+// optional .proto.ClientPayload.ConnectType connectType = 12;
+inline bool ClientPayload::_internal_has_connecttype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_connecttype() const {
+  return _internal_has_connecttype();
+}
+inline void ClientPayload::clear_connecttype() {
+  _impl_.connecttype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline ::proto::ClientPayload_ConnectType ClientPayload::_internal_connecttype() const {
+  return static_cast< ::proto::ClientPayload_ConnectType >(_impl_.connecttype_);
+}
+inline ::proto::ClientPayload_ConnectType ClientPayload::connecttype() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectType)
+  return _internal_connecttype();
+}
+inline void ClientPayload::_internal_set_connecttype(::proto::ClientPayload_ConnectType value) {
+  assert(::proto::ClientPayload_ConnectType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.connecttype_ = value;
+}
+inline void ClientPayload::set_connecttype(::proto::ClientPayload_ConnectType value) {
+  _internal_set_connecttype(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectType)
+}
+
+// optional .proto.ClientPayload.ConnectReason connectReason = 13;
+inline bool ClientPayload::_internal_has_connectreason() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_connectreason() const {
+  return _internal_has_connectreason();
+}
+inline void ClientPayload::clear_connectreason() {
+  _impl_.connectreason_ = 0;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline ::proto::ClientPayload_ConnectReason ClientPayload::_internal_connectreason() const {
+  return static_cast< ::proto::ClientPayload_ConnectReason >(_impl_.connectreason_);
+}
+inline ::proto::ClientPayload_ConnectReason ClientPayload::connectreason() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectReason)
+  return _internal_connectreason();
+}
+inline void ClientPayload::_internal_set_connectreason(::proto::ClientPayload_ConnectReason value) {
+  assert(::proto::ClientPayload_ConnectReason_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.connectreason_ = value;
+}
+inline void ClientPayload::set_connectreason(::proto::ClientPayload_ConnectReason value) {
+  _internal_set_connectreason(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectReason)
+}
+
+// repeated int32 shards = 14;
+inline int ClientPayload::_internal_shards_size() const {
+  return _impl_.shards_.size();
+}
+inline int ClientPayload::shards_size() const {
+  return _internal_shards_size();
+}
+inline void ClientPayload::clear_shards() {
+  _impl_.shards_.Clear();
+}
+inline int32_t ClientPayload::_internal_shards(int index) const {
+  return _impl_.shards_.Get(index);
+}
+inline int32_t ClientPayload::shards(int index) const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.shards)
+  return _internal_shards(index);
+}
+inline void ClientPayload::set_shards(int index, int32_t value) {
+  _impl_.shards_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.shards)
+}
+inline void ClientPayload::_internal_add_shards(int32_t value) {
+  _impl_.shards_.Add(value);
+}
+inline void ClientPayload::add_shards(int32_t value) {
+  _internal_add_shards(value);
+  // @@protoc_insertion_point(field_add:proto.ClientPayload.shards)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+ClientPayload::_internal_shards() const {
+  return _impl_.shards_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+ClientPayload::shards() const {
+  // @@protoc_insertion_point(field_list:proto.ClientPayload.shards)
+  return _internal_shards();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+ClientPayload::_internal_mutable_shards() {
+  return &_impl_.shards_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+ClientPayload::mutable_shards() {
+  // @@protoc_insertion_point(field_mutable_list:proto.ClientPayload.shards)
+  return _internal_mutable_shards();
+}
+
+// optional .proto.ClientPayload.DNSSource dnsSource = 15;
+inline bool ClientPayload::_internal_has_dnssource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.dnssource_ != nullptr);
+  return value;
+}
+inline bool ClientPayload::has_dnssource() const {
+  return _internal_has_dnssource();
+}
+inline void ClientPayload::clear_dnssource() {
+  if (_impl_.dnssource_ != nullptr) _impl_.dnssource_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::ClientPayload_DNSSource& ClientPayload::_internal_dnssource() const {
+  const ::proto::ClientPayload_DNSSource* p = _impl_.dnssource_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_DNSSource&>(
+      ::proto::_ClientPayload_DNSSource_default_instance_);
+}
+inline const ::proto::ClientPayload_DNSSource& ClientPayload::dnssource() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.dnsSource)
+  return _internal_dnssource();
+}
+inline void ClientPayload::unsafe_arena_set_allocated_dnssource(
+    ::proto::ClientPayload_DNSSource* dnssource) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dnssource_);
+  }
+  _impl_.dnssource_ = dnssource;
+  if (dnssource) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.dnsSource)
+}
+inline ::proto::ClientPayload_DNSSource* ClientPayload::release_dnssource() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_;
+  _impl_.dnssource_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_DNSSource* ClientPayload::unsafe_arena_release_dnssource() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.dnsSource)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_;
+  _impl_.dnssource_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_DNSSource* ClientPayload::_internal_mutable_dnssource() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.dnssource_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_DNSSource>(GetArenaForAllocation());
+    _impl_.dnssource_ = p;
+  }
+  return _impl_.dnssource_;
+}
+inline ::proto::ClientPayload_DNSSource* ClientPayload::mutable_dnssource() {
+  ::proto::ClientPayload_DNSSource* _msg = _internal_mutable_dnssource();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.dnsSource)
+  return _msg;
+}
+inline void ClientPayload::set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.dnssource_;
+  }
+  if (dnssource) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dnssource);
+    if (message_arena != submessage_arena) {
+      dnssource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, dnssource, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.dnssource_ = dnssource;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.dnsSource)
+}
+
+// optional uint32 connectAttemptCount = 16;
+inline bool ClientPayload::_internal_has_connectattemptcount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_connectattemptcount() const {
+  return _internal_has_connectattemptcount();
+}
+inline void ClientPayload::clear_connectattemptcount() {
+  _impl_.connectattemptcount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline uint32_t ClientPayload::_internal_connectattemptcount() const {
+  return _impl_.connectattemptcount_;
+}
+inline uint32_t ClientPayload::connectattemptcount() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectAttemptCount)
+  return _internal_connectattemptcount();
+}
+inline void ClientPayload::_internal_set_connectattemptcount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.connectattemptcount_ = value;
+}
+inline void ClientPayload::set_connectattemptcount(uint32_t value) {
+  _internal_set_connectattemptcount(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectAttemptCount)
+}
+
+// optional uint32 device = 18;
+inline bool ClientPayload::_internal_has_device() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_device() const {
+  return _internal_has_device();
+}
+inline void ClientPayload::clear_device() {
+  _impl_.device_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline uint32_t ClientPayload::_internal_device() const {
+  return _impl_.device_;
+}
+inline uint32_t ClientPayload::device() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.device)
+  return _internal_device();
+}
+inline void ClientPayload::_internal_set_device(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.device_ = value;
+}
+inline void ClientPayload::set_device(uint32_t value) {
+  _internal_set_device(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.device)
+}
+
+// optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
+inline bool ClientPayload::_internal_has_devicepairingdata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.devicepairingdata_ != nullptr);
+  return value;
+}
+inline bool ClientPayload::has_devicepairingdata() const {
+  return _internal_has_devicepairingdata();
+}
+inline void ClientPayload::clear_devicepairingdata() {
+  if (_impl_.devicepairingdata_ != nullptr) _impl_.devicepairingdata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::_internal_devicepairingdata() const {
+  const ::proto::ClientPayload_DevicePairingRegistrationData* p = _impl_.devicepairingdata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_DevicePairingRegistrationData&>(
+      ::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_);
+}
+inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::devicepairingdata() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.devicePairingData)
+  return _internal_devicepairingdata();
+}
+inline void ClientPayload::unsafe_arena_set_allocated_devicepairingdata(
+    ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicepairingdata_);
+  }
+  _impl_.devicepairingdata_ = devicepairingdata;
+  if (devicepairingdata) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.devicePairingData)
+}
+inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::release_devicepairingdata() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_;
+  _impl_.devicepairingdata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::unsafe_arena_release_devicepairingdata() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.devicePairingData)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_;
+  _impl_.devicepairingdata_ = nullptr;
+  return temp;
+}
+inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::_internal_mutable_devicepairingdata() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.devicepairingdata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(GetArenaForAllocation());
+    _impl_.devicepairingdata_ = p;
+  }
+  return _impl_.devicepairingdata_;
+}
+inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::mutable_devicepairingdata() {
+  ::proto::ClientPayload_DevicePairingRegistrationData* _msg = _internal_mutable_devicepairingdata();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.devicePairingData)
+  return _msg;
+}
+inline void ClientPayload::set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.devicepairingdata_;
+  }
+  if (devicepairingdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicepairingdata);
+    if (message_arena != submessage_arena) {
+      devicepairingdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, devicepairingdata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.devicepairingdata_ = devicepairingdata;
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.devicePairingData)
+}
+
+// optional .proto.ClientPayload.Product product = 20;
+inline bool ClientPayload::_internal_has_product() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_product() const {
+  return _internal_has_product();
+}
+inline void ClientPayload::clear_product() {
+  _impl_.product_ = 0;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline ::proto::ClientPayload_Product ClientPayload::_internal_product() const {
+  return static_cast< ::proto::ClientPayload_Product >(_impl_.product_);
+}
+inline ::proto::ClientPayload_Product ClientPayload::product() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.product)
+  return _internal_product();
+}
+inline void ClientPayload::_internal_set_product(::proto::ClientPayload_Product value) {
+  assert(::proto::ClientPayload_Product_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.product_ = value;
+}
+inline void ClientPayload::set_product(::proto::ClientPayload_Product value) {
+  _internal_set_product(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.product)
+}
+
+// optional bytes fbCat = 21;
+inline bool ClientPayload::_internal_has_fbcat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_fbcat() const {
+  return _internal_has_fbcat();
+}
+inline void ClientPayload::clear_fbcat() {
+  _impl_.fbcat_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPayload::fbcat() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbCat)
+  return _internal_fbcat();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload::set_fbcat(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.fbcat_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbCat)
+}
+inline std::string* ClientPayload::mutable_fbcat() {
+  std::string* _s = _internal_mutable_fbcat();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbCat)
+  return _s;
+}
+inline const std::string& ClientPayload::_internal_fbcat() const {
+  return _impl_.fbcat_.Get();
+}
+inline void ClientPayload::_internal_set_fbcat(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.fbcat_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload::_internal_mutable_fbcat() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.fbcat_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload::release_fbcat() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbCat)
+  if (!_internal_has_fbcat()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.fbcat_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbcat_.IsDefault()) {
+    _impl_.fbcat_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload::set_allocated_fbcat(std::string* fbcat) {
+  if (fbcat != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.fbcat_.SetAllocated(fbcat, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbcat_.IsDefault()) {
+    _impl_.fbcat_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbCat)
+}
+
+// optional bytes fbUserAgent = 22;
+inline bool ClientPayload::_internal_has_fbuseragent() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_fbuseragent() const {
+  return _internal_has_fbuseragent();
+}
+inline void ClientPayload::clear_fbuseragent() {
+  _impl_.fbuseragent_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientPayload::fbuseragent() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbUserAgent)
+  return _internal_fbuseragent();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload::set_fbuseragent(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fbuseragent_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbUserAgent)
+}
+inline std::string* ClientPayload::mutable_fbuseragent() {
+  std::string* _s = _internal_mutable_fbuseragent();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbUserAgent)
+  return _s;
+}
+inline const std::string& ClientPayload::_internal_fbuseragent() const {
+  return _impl_.fbuseragent_.Get();
+}
+inline void ClientPayload::_internal_set_fbuseragent(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fbuseragent_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload::_internal_mutable_fbuseragent() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fbuseragent_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload::release_fbuseragent() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbUserAgent)
+  if (!_internal_has_fbuseragent()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fbuseragent_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbuseragent_.IsDefault()) {
+    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload::set_allocated_fbuseragent(std::string* fbuseragent) {
+  if (fbuseragent != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fbuseragent_.SetAllocated(fbuseragent, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbuseragent_.IsDefault()) {
+    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbUserAgent)
+}
+
+// optional bool oc = 23;
+inline bool ClientPayload::_internal_has_oc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_oc() const {
+  return _internal_has_oc();
+}
+inline void ClientPayload::clear_oc() {
+  _impl_.oc_ = false;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline bool ClientPayload::_internal_oc() const {
+  return _impl_.oc_;
+}
+inline bool ClientPayload::oc() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.oc)
+  return _internal_oc();
+}
+inline void ClientPayload::_internal_set_oc(bool value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.oc_ = value;
+}
+inline void ClientPayload::set_oc(bool value) {
+  _internal_set_oc(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.oc)
+}
+
+// optional int32 lc = 24;
+inline bool ClientPayload::_internal_has_lc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_lc() const {
+  return _internal_has_lc();
+}
+inline void ClientPayload::clear_lc() {
+  _impl_.lc_ = 0;
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline int32_t ClientPayload::_internal_lc() const {
+  return _impl_.lc_;
+}
+inline int32_t ClientPayload::lc() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.lc)
+  return _internal_lc();
+}
+inline void ClientPayload::_internal_set_lc(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.lc_ = value;
+}
+inline void ClientPayload::set_lc(int32_t value) {
+  _internal_set_lc(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.lc)
+}
+
+// optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
+inline bool ClientPayload::_internal_has_iosappextension() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_iosappextension() const {
+  return _internal_has_iosappextension();
+}
+inline void ClientPayload::clear_iosappextension() {
+  _impl_.iosappextension_ = 0;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline ::proto::ClientPayload_IOSAppExtension ClientPayload::_internal_iosappextension() const {
+  return static_cast< ::proto::ClientPayload_IOSAppExtension >(_impl_.iosappextension_);
+}
+inline ::proto::ClientPayload_IOSAppExtension ClientPayload::iosappextension() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.iosAppExtension)
+  return _internal_iosappextension();
+}
+inline void ClientPayload::_internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value) {
+  assert(::proto::ClientPayload_IOSAppExtension_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.iosappextension_ = value;
+}
+inline void ClientPayload::set_iosappextension(::proto::ClientPayload_IOSAppExtension value) {
+  _internal_set_iosappextension(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.iosAppExtension)
+}
+
+// optional uint64 fbAppId = 31;
+inline bool ClientPayload::_internal_has_fbappid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_fbappid() const {
+  return _internal_has_fbappid();
+}
+inline void ClientPayload::clear_fbappid() {
+  _impl_.fbappid_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline uint64_t ClientPayload::_internal_fbappid() const {
+  return _impl_.fbappid_;
+}
+inline uint64_t ClientPayload::fbappid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbAppId)
+  return _internal_fbappid();
+}
+inline void ClientPayload::_internal_set_fbappid(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.fbappid_ = value;
+}
+inline void ClientPayload::set_fbappid(uint64_t value) {
+  _internal_set_fbappid(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbAppId)
+}
+
+// optional bytes fbDeviceId = 32;
+inline bool ClientPayload::_internal_has_fbdeviceid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_fbdeviceid() const {
+  return _internal_has_fbdeviceid();
+}
+inline void ClientPayload::clear_fbdeviceid() {
+  _impl_.fbdeviceid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientPayload::fbdeviceid() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbDeviceId)
+  return _internal_fbdeviceid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload::set_fbdeviceid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.fbdeviceid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbDeviceId)
+}
+inline std::string* ClientPayload::mutable_fbdeviceid() {
+  std::string* _s = _internal_mutable_fbdeviceid();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbDeviceId)
+  return _s;
+}
+inline const std::string& ClientPayload::_internal_fbdeviceid() const {
+  return _impl_.fbdeviceid_.Get();
+}
+inline void ClientPayload::_internal_set_fbdeviceid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.fbdeviceid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload::_internal_mutable_fbdeviceid() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.fbdeviceid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload::release_fbdeviceid() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbDeviceId)
+  if (!_internal_has_fbdeviceid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.fbdeviceid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbdeviceid_.IsDefault()) {
+    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload::set_allocated_fbdeviceid(std::string* fbdeviceid) {
+  if (fbdeviceid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.fbdeviceid_.SetAllocated(fbdeviceid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fbdeviceid_.IsDefault()) {
+    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbDeviceId)
+}
+
+// optional bool pull = 33;
+inline bool ClientPayload::_internal_has_pull() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_pull() const {
+  return _internal_has_pull();
+}
+inline void ClientPayload::clear_pull() {
+  _impl_.pull_ = false;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline bool ClientPayload::_internal_pull() const {
+  return _impl_.pull_;
+}
+inline bool ClientPayload::pull() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.pull)
+  return _internal_pull();
+}
+inline void ClientPayload::_internal_set_pull(bool value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.pull_ = value;
+}
+inline void ClientPayload::set_pull(bool value) {
+  _internal_set_pull(value);
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.pull)
+}
+
+// optional bytes paddingBytes = 34;
+inline bool ClientPayload::_internal_has_paddingbytes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientPayload::has_paddingbytes() const {
+  return _internal_has_paddingbytes();
+}
+inline void ClientPayload::clear_paddingbytes() {
+  _impl_.paddingbytes_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientPayload::paddingbytes() const {
+  // @@protoc_insertion_point(field_get:proto.ClientPayload.paddingBytes)
+  return _internal_paddingbytes();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPayload::set_paddingbytes(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.paddingbytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ClientPayload.paddingBytes)
+}
+inline std::string* ClientPayload::mutable_paddingbytes() {
+  std::string* _s = _internal_mutable_paddingbytes();
+  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.paddingBytes)
+  return _s;
+}
+inline const std::string& ClientPayload::_internal_paddingbytes() const {
+  return _impl_.paddingbytes_.Get();
+}
+inline void ClientPayload::_internal_set_paddingbytes(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.paddingbytes_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPayload::_internal_mutable_paddingbytes() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.paddingbytes_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPayload::release_paddingbytes() {
+  // @@protoc_insertion_point(field_release:proto.ClientPayload.paddingBytes)
+  if (!_internal_has_paddingbytes()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.paddingbytes_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paddingbytes_.IsDefault()) {
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPayload::set_allocated_paddingbytes(std::string* paddingbytes) {
+  if (paddingbytes != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paddingbytes_.IsDefault()) {
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.paddingBytes)
+}
+
+// -------------------------------------------------------------------
+
+// ContextInfo_AdReplyInfo
+
+// optional string advertiserName = 1;
+inline bool ContextInfo_AdReplyInfo::_internal_has_advertisername() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContextInfo_AdReplyInfo::has_advertisername() const {
+  return _internal_has_advertisername();
+}
+inline void ContextInfo_AdReplyInfo::clear_advertisername() {
+  _impl_.advertisername_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContextInfo_AdReplyInfo::advertisername() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.advertiserName)
+  return _internal_advertisername();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_AdReplyInfo::set_advertisername(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.advertisername_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.advertiserName)
+}
+inline std::string* ContextInfo_AdReplyInfo::mutable_advertisername() {
+  std::string* _s = _internal_mutable_advertisername();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.advertiserName)
+  return _s;
+}
+inline const std::string& ContextInfo_AdReplyInfo::_internal_advertisername() const {
+  return _impl_.advertisername_.Get();
+}
+inline void ContextInfo_AdReplyInfo::_internal_set_advertisername(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.advertisername_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_advertisername() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.advertisername_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::release_advertisername() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.advertiserName)
+  if (!_internal_has_advertisername()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.advertisername_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.advertisername_.IsDefault()) {
+    _impl_.advertisername_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_AdReplyInfo::set_allocated_advertisername(std::string* advertisername) {
+  if (advertisername != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.advertisername_.SetAllocated(advertisername, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.advertisername_.IsDefault()) {
+    _impl_.advertisername_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.advertiserName)
+}
+
+// optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
+inline bool ContextInfo_AdReplyInfo::_internal_has_mediatype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ContextInfo_AdReplyInfo::has_mediatype() const {
+  return _internal_has_mediatype();
+}
+inline void ContextInfo_AdReplyInfo::clear_mediatype() {
+  _impl_.mediatype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::_internal_mediatype() const {
+  return static_cast< ::proto::ContextInfo_AdReplyInfo_MediaType >(_impl_.mediatype_);
+}
+inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::mediatype() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.mediaType)
+  return _internal_mediatype();
+}
+inline void ContextInfo_AdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) {
+  assert(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediatype_ = value;
+}
+inline void ContextInfo_AdReplyInfo::set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) {
+  _internal_set_mediatype(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.mediaType)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool ContextInfo_AdReplyInfo::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ContextInfo_AdReplyInfo::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void ContextInfo_AdReplyInfo::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ContextInfo_AdReplyInfo::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_AdReplyInfo::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
+}
+inline std::string* ContextInfo_AdReplyInfo::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
+  return _s;
+}
+inline const std::string& ContextInfo_AdReplyInfo::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void ContextInfo_AdReplyInfo::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_AdReplyInfo::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
+}
+
+// optional string caption = 17;
+inline bool ContextInfo_AdReplyInfo::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ContextInfo_AdReplyInfo::has_caption() const {
+  return _internal_has_caption();
+}
+inline void ContextInfo_AdReplyInfo::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ContextInfo_AdReplyInfo::caption() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_AdReplyInfo::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.caption)
+}
+inline std::string* ContextInfo_AdReplyInfo::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.caption)
+  return _s;
+}
+inline const std::string& ContextInfo_AdReplyInfo::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void ContextInfo_AdReplyInfo::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_AdReplyInfo::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_AdReplyInfo::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.caption)
+}
+
+// -------------------------------------------------------------------
+
+// ContextInfo_ExternalAdReplyInfo
+
+// optional string title = 1;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_title() const {
+  return _internal_has_title();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::title() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.title)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.title)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_title() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.title)
+}
+
+// optional string body = 2;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_body() const {
+  return _internal_has_body();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::body() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.body)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.body)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_body() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.body)
+}
+
+// optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediatype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_mediatype() const {
+  return _internal_has_mediatype();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_mediatype() {
+  _impl_.mediatype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::_internal_mediatype() const {
+  return static_cast< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType >(_impl_.mediatype_);
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::mediatype() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaType)
+  return _internal_mediatype();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) {
+  assert(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.mediatype_ = value;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) {
+  _internal_set_mediatype(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaType)
+}
+
+// optional string thumbnailUrl = 4;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnailurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnailurl() const {
+  return _internal_has_thumbnailurl();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnailurl() {
+  _impl_.thumbnailurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnailurl() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
+  return _internal_thumbnailurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_thumbnailurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.thumbnailurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnailurl() {
+  std::string* _s = _internal_mutable_thumbnailurl();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnailurl() const {
+  return _impl_.thumbnailurl_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnailurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.thumbnailurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnailurl() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.thumbnailurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnailurl() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
+  if (!_internal_has_thumbnailurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.thumbnailurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailurl_.IsDefault()) {
+    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnailurl(std::string* thumbnailurl) {
+  if (thumbnailurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.thumbnailurl_.SetAllocated(thumbnailurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailurl_.IsDefault()) {
+    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
+}
+
+// optional string mediaUrl = 5;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediaurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_mediaurl() const {
+  return _internal_has_mediaurl();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_mediaurl() {
+  _impl_.mediaurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::mediaurl() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
+  return _internal_mediaurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_mediaurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mediaurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_mediaurl() {
+  std::string* _s = _internal_mutable_mediaurl();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_mediaurl() const {
+  return _impl_.mediaurl_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediaurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediaurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_mediaurl() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mediaurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_mediaurl() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
+  if (!_internal_has_mediaurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mediaurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediaurl_.IsDefault()) {
+    _impl_.mediaurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_mediaurl(std::string* mediaurl) {
+  if (mediaurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mediaurl_.SetAllocated(mediaurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediaurl_.IsDefault()) {
+    _impl_.mediaurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
+}
+
+// optional bytes thumbnail = 6;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnail() const {
+  return _internal_has_thumbnail();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnail() {
+  _impl_.thumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
+  return _internal_thumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_thumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.thumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnail() {
+  std::string* _s = _internal_mutable_thumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnail() const {
+  return _impl_.thumbnail_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.thumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnail() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.thumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnail() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
+  if (!_internal_has_thumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.thumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnail_.IsDefault()) {
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnail(std::string* thumbnail) {
+  if (thumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnail_.IsDefault()) {
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
+}
+
+// optional string sourceType = 7;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourcetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_sourcetype() const {
+  return _internal_has_sourcetype();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_sourcetype() {
+  _impl_.sourcetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::sourcetype() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
+  return _internal_sourcetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_sourcetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.sourcetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourcetype() {
+  std::string* _s = _internal_mutable_sourcetype();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourcetype() const {
+  return _impl_.sourcetype_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourcetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.sourcetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourcetype() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.sourcetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourcetype() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
+  if (!_internal_has_sourcetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.sourcetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourcetype_.IsDefault()) {
+    _impl_.sourcetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourcetype(std::string* sourcetype) {
+  if (sourcetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.sourcetype_.SetAllocated(sourcetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourcetype_.IsDefault()) {
+    _impl_.sourcetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
+}
+
+// optional string sourceId = 8;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_sourceid() const {
+  return _internal_has_sourceid();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_sourceid() {
+  _impl_.sourceid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceid() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
+  return _internal_sourceid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_sourceid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.sourceid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceid() {
+  std::string* _s = _internal_mutable_sourceid();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceid() const {
+  return _impl_.sourceid_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.sourceid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceid() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.sourceid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceid() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
+  if (!_internal_has_sourceid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.sourceid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourceid_.IsDefault()) {
+    _impl_.sourceid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceid(std::string* sourceid) {
+  if (sourceid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.sourceid_.SetAllocated(sourceid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourceid_.IsDefault()) {
+    _impl_.sourceid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
+}
+
+// optional string sourceUrl = 9;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_sourceurl() const {
+  return _internal_has_sourceurl();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_sourceurl() {
+  _impl_.sourceurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceurl() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
+  return _internal_sourceurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo_ExternalAdReplyInfo::set_sourceurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.sourceurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceurl() {
+  std::string* _s = _internal_mutable_sourceurl();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
+  return _s;
+}
+inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceurl() const {
+  return _impl_.sourceurl_.Get();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.sourceurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceurl() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.sourceurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceurl() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
+  if (!_internal_has_sourceurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.sourceurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourceurl_.IsDefault()) {
+    _impl_.sourceurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceurl(std::string* sourceurl) {
+  if (sourceurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.sourceurl_.SetAllocated(sourceurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sourceurl_.IsDefault()) {
+    _impl_.sourceurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
+}
+
+// optional bool containsAutoReply = 10;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_containsautoreply() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_containsautoreply() const {
+  return _internal_has_containsautoreply();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_containsautoreply() {
+  _impl_.containsautoreply_ = false;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_containsautoreply() const {
+  return _impl_.containsautoreply_;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::containsautoreply() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply)
+  return _internal_containsautoreply();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_containsautoreply(bool value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.containsautoreply_ = value;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_containsautoreply(bool value) {
+  _internal_set_containsautoreply(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply)
+}
+
+// optional bool renderLargerThumbnail = 11;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_renderlargerthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_renderlargerthumbnail() const {
+  return _internal_has_renderlargerthumbnail();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_renderlargerthumbnail() {
+  _impl_.renderlargerthumbnail_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_renderlargerthumbnail() const {
+  return _impl_.renderlargerthumbnail_;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::renderlargerthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail)
+  return _internal_renderlargerthumbnail();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_renderlargerthumbnail(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.renderlargerthumbnail_ = value;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_renderlargerthumbnail(bool value) {
+  _internal_set_renderlargerthumbnail(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail)
+}
+
+// optional bool showAdAttribution = 12;
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_showadattribution() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::has_showadattribution() const {
+  return _internal_has_showadattribution();
+}
+inline void ContextInfo_ExternalAdReplyInfo::clear_showadattribution() {
+  _impl_.showadattribution_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::_internal_showadattribution() const {
+  return _impl_.showadattribution_;
+}
+inline bool ContextInfo_ExternalAdReplyInfo::showadattribution() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution)
+  return _internal_showadattribution();
+}
+inline void ContextInfo_ExternalAdReplyInfo::_internal_set_showadattribution(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.showadattribution_ = value;
+}
+inline void ContextInfo_ExternalAdReplyInfo::set_showadattribution(bool value) {
+  _internal_set_showadattribution(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution)
+}
+
+// -------------------------------------------------------------------
+
+// ContextInfo
+
+// optional string stanzaId = 1;
+inline bool ContextInfo::_internal_has_stanzaid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_stanzaid() const {
+  return _internal_has_stanzaid();
+}
+inline void ContextInfo::clear_stanzaid() {
+  _impl_.stanzaid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContextInfo::stanzaid() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.stanzaId)
+  return _internal_stanzaid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_stanzaid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.stanzaId)
+}
+inline std::string* ContextInfo::mutable_stanzaid() {
+  std::string* _s = _internal_mutable_stanzaid();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.stanzaId)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_stanzaid() const {
+  return _impl_.stanzaid_.Get();
+}
+inline void ContextInfo::_internal_set_stanzaid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_stanzaid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_stanzaid() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.stanzaId)
+  if (!_internal_has_stanzaid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.stanzaid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_stanzaid(std::string* stanzaid) {
+  if (stanzaid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.stanzaId)
+}
+
+// optional string participant = 2;
+inline bool ContextInfo::_internal_has_participant() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_participant() const {
+  return _internal_has_participant();
+}
+inline void ContextInfo::clear_participant() {
+  _impl_.participant_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ContextInfo::participant() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.participant)
+  return _internal_participant();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_participant(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.participant)
+}
+inline std::string* ContextInfo::mutable_participant() {
+  std::string* _s = _internal_mutable_participant();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.participant)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_participant() const {
+  return _impl_.participant_.Get();
+}
+inline void ContextInfo::_internal_set_participant(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.participant_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_participant() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.participant_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_participant() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.participant)
+  if (!_internal_has_participant()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.participant_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_participant(std::string* participant) {
+  if (participant != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.participant)
+}
+
+// optional .proto.Message quotedMessage = 3;
+inline bool ContextInfo::_internal_has_quotedmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quotedmessage_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_quotedmessage() const {
+  return _internal_has_quotedmessage();
+}
+inline void ContextInfo::clear_quotedmessage() {
+  if (_impl_.quotedmessage_ != nullptr) _impl_.quotedmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const ::proto::Message& ContextInfo::_internal_quotedmessage() const {
+  const ::proto::Message* p = _impl_.quotedmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& ContextInfo::quotedmessage() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedMessage)
+  return _internal_quotedmessage();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_quotedmessage(
+    ::proto::Message* quotedmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmessage_);
+  }
+  _impl_.quotedmessage_ = quotedmessage;
+  if (quotedmessage) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedMessage)
+}
+inline ::proto::Message* ContextInfo::release_quotedmessage() {
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::Message* temp = _impl_.quotedmessage_;
+  _impl_.quotedmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* ContextInfo::unsafe_arena_release_quotedmessage() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedMessage)
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::Message* temp = _impl_.quotedmessage_;
+  _impl_.quotedmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* ContextInfo::_internal_mutable_quotedmessage() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  if (_impl_.quotedmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.quotedmessage_ = p;
+  }
+  return _impl_.quotedmessage_;
+}
+inline ::proto::Message* ContextInfo::mutable_quotedmessage() {
+  ::proto::Message* _msg = _internal_mutable_quotedmessage();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedMessage)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_quotedmessage(::proto::Message* quotedmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quotedmessage_;
+  }
+  if (quotedmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmessage);
+    if (message_arena != submessage_arena) {
+      quotedmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quotedmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.quotedmessage_ = quotedmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedMessage)
+}
+
+// optional string remoteJid = 4;
+inline bool ContextInfo::_internal_has_remotejid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_remotejid() const {
+  return _internal_has_remotejid();
+}
+inline void ContextInfo::clear_remotejid() {
+  _impl_.remotejid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ContextInfo::remotejid() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.remoteJid)
+  return _internal_remotejid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_remotejid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.remotejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.remoteJid)
+}
+inline std::string* ContextInfo::mutable_remotejid() {
+  std::string* _s = _internal_mutable_remotejid();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.remoteJid)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_remotejid() const {
+  return _impl_.remotejid_.Get();
+}
+inline void ContextInfo::_internal_set_remotejid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.remotejid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_remotejid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.remotejid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_remotejid() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.remoteJid)
+  if (!_internal_has_remotejid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.remotejid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remotejid_.IsDefault()) {
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_remotejid(std::string* remotejid) {
+  if (remotejid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remotejid_.IsDefault()) {
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.remoteJid)
+}
+
+// repeated string mentionedJid = 15;
+inline int ContextInfo::_internal_mentionedjid_size() const {
+  return _impl_.mentionedjid_.size();
+}
+inline int ContextInfo::mentionedjid_size() const {
+  return _internal_mentionedjid_size();
+}
+inline void ContextInfo::clear_mentionedjid() {
+  _impl_.mentionedjid_.Clear();
+}
+inline std::string* ContextInfo::add_mentionedjid() {
+  std::string* _s = _internal_add_mentionedjid();
+  // @@protoc_insertion_point(field_add_mutable:proto.ContextInfo.mentionedJid)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_mentionedjid(int index) const {
+  return _impl_.mentionedjid_.Get(index);
+}
+inline const std::string& ContextInfo::mentionedjid(int index) const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.mentionedJid)
+  return _internal_mentionedjid(index);
+}
+inline std::string* ContextInfo::mutable_mentionedjid(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.mentionedJid)
+  return _impl_.mentionedjid_.Mutable(index);
+}
+inline void ContextInfo::set_mentionedjid(int index, const std::string& value) {
+  _impl_.mentionedjid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::set_mentionedjid(int index, std::string&& value) {
+  _impl_.mentionedjid_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::set_mentionedjid(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.mentionedjid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::set_mentionedjid(int index, const char* value, size_t size) {
+  _impl_.mentionedjid_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.ContextInfo.mentionedJid)
+}
+inline std::string* ContextInfo::_internal_add_mentionedjid() {
+  return _impl_.mentionedjid_.Add();
+}
+inline void ContextInfo::add_mentionedjid(const std::string& value) {
+  _impl_.mentionedjid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::add_mentionedjid(std::string&& value) {
+  _impl_.mentionedjid_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::add_mentionedjid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.mentionedjid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.ContextInfo.mentionedJid)
+}
+inline void ContextInfo::add_mentionedjid(const char* value, size_t size) {
+  _impl_.mentionedjid_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.ContextInfo.mentionedJid)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ContextInfo::mentionedjid() const {
+  // @@protoc_insertion_point(field_list:proto.ContextInfo.mentionedJid)
+  return _impl_.mentionedjid_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ContextInfo::mutable_mentionedjid() {
+  // @@protoc_insertion_point(field_mutable_list:proto.ContextInfo.mentionedJid)
+  return &_impl_.mentionedjid_;
+}
+
+// optional string conversionSource = 18;
+inline bool ContextInfo::_internal_has_conversionsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_conversionsource() const {
+  return _internal_has_conversionsource();
+}
+inline void ContextInfo::clear_conversionsource() {
+  _impl_.conversionsource_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ContextInfo::conversionsource() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionSource)
+  return _internal_conversionsource();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_conversionsource(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.conversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionSource)
+}
+inline std::string* ContextInfo::mutable_conversionsource() {
+  std::string* _s = _internal_mutable_conversionsource();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionSource)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_conversionsource() const {
+  return _impl_.conversionsource_.Get();
+}
+inline void ContextInfo::_internal_set_conversionsource(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.conversionsource_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_conversionsource() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.conversionsource_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_conversionsource() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionSource)
+  if (!_internal_has_conversionsource()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.conversionsource_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversionsource_.IsDefault()) {
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_conversionsource(std::string* conversionsource) {
+  if (conversionsource != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversionsource_.IsDefault()) {
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionSource)
+}
+
+// optional bytes conversionData = 19;
+inline bool ContextInfo::_internal_has_conversiondata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_conversiondata() const {
+  return _internal_has_conversiondata();
+}
+inline void ContextInfo::clear_conversiondata() {
+  _impl_.conversiondata_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ContextInfo::conversiondata() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionData)
+  return _internal_conversiondata();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_conversiondata(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.conversiondata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionData)
+}
+inline std::string* ContextInfo::mutable_conversiondata() {
+  std::string* _s = _internal_mutable_conversiondata();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionData)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_conversiondata() const {
+  return _impl_.conversiondata_.Get();
+}
+inline void ContextInfo::_internal_set_conversiondata(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.conversiondata_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_conversiondata() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.conversiondata_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_conversiondata() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionData)
+  if (!_internal_has_conversiondata()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.conversiondata_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversiondata_.IsDefault()) {
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_conversiondata(std::string* conversiondata) {
+  if (conversiondata != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversiondata_.IsDefault()) {
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionData)
+}
+
+// optional uint32 conversionDelaySeconds = 20;
+inline bool ContextInfo::_internal_has_conversiondelayseconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_conversiondelayseconds() const {
+  return _internal_has_conversiondelayseconds();
+}
+inline void ContextInfo::clear_conversiondelayseconds() {
+  _impl_.conversiondelayseconds_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline uint32_t ContextInfo::_internal_conversiondelayseconds() const {
+  return _impl_.conversiondelayseconds_;
+}
+inline uint32_t ContextInfo::conversiondelayseconds() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionDelaySeconds)
+  return _internal_conversiondelayseconds();
+}
+inline void ContextInfo::_internal_set_conversiondelayseconds(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.conversiondelayseconds_ = value;
+}
+inline void ContextInfo::set_conversiondelayseconds(uint32_t value) {
+  _internal_set_conversiondelayseconds(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionDelaySeconds)
+}
+
+// optional uint32 forwardingScore = 21;
+inline bool ContextInfo::_internal_has_forwardingscore() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_forwardingscore() const {
+  return _internal_has_forwardingscore();
+}
+inline void ContextInfo::clear_forwardingscore() {
+  _impl_.forwardingscore_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline uint32_t ContextInfo::_internal_forwardingscore() const {
+  return _impl_.forwardingscore_;
+}
+inline uint32_t ContextInfo::forwardingscore() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.forwardingScore)
+  return _internal_forwardingscore();
+}
+inline void ContextInfo::_internal_set_forwardingscore(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.forwardingscore_ = value;
+}
+inline void ContextInfo::set_forwardingscore(uint32_t value) {
+  _internal_set_forwardingscore(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.forwardingScore)
+}
+
+// optional bool isForwarded = 22;
+inline bool ContextInfo::_internal_has_isforwarded() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_isforwarded() const {
+  return _internal_has_isforwarded();
+}
+inline void ContextInfo::clear_isforwarded() {
+  _impl_.isforwarded_ = false;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline bool ContextInfo::_internal_isforwarded() const {
+  return _impl_.isforwarded_;
+}
+inline bool ContextInfo::isforwarded() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.isForwarded)
+  return _internal_isforwarded();
+}
+inline void ContextInfo::_internal_set_isforwarded(bool value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.isforwarded_ = value;
+}
+inline void ContextInfo::set_isforwarded(bool value) {
+  _internal_set_isforwarded(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.isForwarded)
+}
+
+// optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
+inline bool ContextInfo::_internal_has_quotedad() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quotedad_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_quotedad() const {
+  return _internal_has_quotedad();
+}
+inline void ContextInfo::clear_quotedad() {
+  if (_impl_.quotedad_ != nullptr) _impl_.quotedad_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::_internal_quotedad() const {
+  const ::proto::ContextInfo_AdReplyInfo* p = _impl_.quotedad_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo_AdReplyInfo&>(
+      ::proto::_ContextInfo_AdReplyInfo_default_instance_);
+}
+inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::quotedad() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedAd)
+  return _internal_quotedad();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_quotedad(
+    ::proto::ContextInfo_AdReplyInfo* quotedad) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedad_);
+  }
+  _impl_.quotedad_ = quotedad;
+  if (quotedad) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedAd)
+}
+inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::release_quotedad() {
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_;
+  _impl_.quotedad_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::unsafe_arena_release_quotedad() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedAd)
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_;
+  _impl_.quotedad_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::_internal_mutable_quotedad() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  if (_impl_.quotedad_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(GetArenaForAllocation());
+    _impl_.quotedad_ = p;
+  }
+  return _impl_.quotedad_;
+}
+inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::mutable_quotedad() {
+  ::proto::ContextInfo_AdReplyInfo* _msg = _internal_mutable_quotedad();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedAd)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quotedad_;
+  }
+  if (quotedad) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedad);
+    if (message_arena != submessage_arena) {
+      quotedad = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quotedad, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.quotedad_ = quotedad;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedAd)
+}
+
+// optional .proto.MessageKey placeholderKey = 24;
+inline bool ContextInfo::_internal_has_placeholderkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.placeholderkey_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_placeholderkey() const {
+  return _internal_has_placeholderkey();
+}
+inline void ContextInfo::clear_placeholderkey() {
+  if (_impl_.placeholderkey_ != nullptr) _impl_.placeholderkey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::MessageKey& ContextInfo::_internal_placeholderkey() const {
+  const ::proto::MessageKey* p = _impl_.placeholderkey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& ContextInfo::placeholderkey() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.placeholderKey)
+  return _internal_placeholderkey();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_placeholderkey(
+    ::proto::MessageKey* placeholderkey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.placeholderkey_);
+  }
+  _impl_.placeholderkey_ = placeholderkey;
+  if (placeholderkey) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.placeholderKey)
+}
+inline ::proto::MessageKey* ContextInfo::release_placeholderkey() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::MessageKey* temp = _impl_.placeholderkey_;
+  _impl_.placeholderkey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* ContextInfo::unsafe_arena_release_placeholderkey() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.placeholderKey)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::MessageKey* temp = _impl_.placeholderkey_;
+  _impl_.placeholderkey_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* ContextInfo::_internal_mutable_placeholderkey() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.placeholderkey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.placeholderkey_ = p;
+  }
+  return _impl_.placeholderkey_;
+}
+inline ::proto::MessageKey* ContextInfo::mutable_placeholderkey() {
+  ::proto::MessageKey* _msg = _internal_mutable_placeholderkey();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.placeholderKey)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_placeholderkey(::proto::MessageKey* placeholderkey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.placeholderkey_;
+  }
+  if (placeholderkey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(placeholderkey);
+    if (message_arena != submessage_arena) {
+      placeholderkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, placeholderkey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.placeholderkey_ = placeholderkey;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.placeholderKey)
+}
+
+// optional uint32 expiration = 25;
+inline bool ContextInfo::_internal_has_expiration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_expiration() const {
+  return _internal_has_expiration();
+}
+inline void ContextInfo::clear_expiration() {
+  _impl_.expiration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline uint32_t ContextInfo::_internal_expiration() const {
+  return _impl_.expiration_;
+}
+inline uint32_t ContextInfo::expiration() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.expiration)
+  return _internal_expiration();
+}
+inline void ContextInfo::_internal_set_expiration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.expiration_ = value;
+}
+inline void ContextInfo::set_expiration(uint32_t value) {
+  _internal_set_expiration(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.expiration)
+}
+
+// optional int64 ephemeralSettingTimestamp = 26;
+inline bool ContextInfo::_internal_has_ephemeralsettingtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_ephemeralsettingtimestamp() const {
+  return _internal_has_ephemeralsettingtimestamp();
+}
+inline void ContextInfo::clear_ephemeralsettingtimestamp() {
+  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline int64_t ContextInfo::_internal_ephemeralsettingtimestamp() const {
+  return _impl_.ephemeralsettingtimestamp_;
+}
+inline int64_t ContextInfo::ephemeralsettingtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSettingTimestamp)
+  return _internal_ephemeralsettingtimestamp();
+}
+inline void ContextInfo::_internal_set_ephemeralsettingtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.ephemeralsettingtimestamp_ = value;
+}
+inline void ContextInfo::set_ephemeralsettingtimestamp(int64_t value) {
+  _internal_set_ephemeralsettingtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSettingTimestamp)
+}
+
+// optional bytes ephemeralSharedSecret = 27;
+inline bool ContextInfo::_internal_has_ephemeralsharedsecret() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_ephemeralsharedsecret() const {
+  return _internal_has_ephemeralsharedsecret();
+}
+inline void ContextInfo::clear_ephemeralsharedsecret() {
+  _impl_.ephemeralsharedsecret_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& ContextInfo::ephemeralsharedsecret() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSharedSecret)
+  return _internal_ephemeralsharedsecret();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.ephemeralsharedsecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSharedSecret)
+}
+inline std::string* ContextInfo::mutable_ephemeralsharedsecret() {
+  std::string* _s = _internal_mutable_ephemeralsharedsecret();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ephemeralSharedSecret)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_ephemeralsharedsecret() const {
+  return _impl_.ephemeralsharedsecret_.Get();
+}
+inline void ContextInfo::_internal_set_ephemeralsharedsecret(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.ephemeralsharedsecret_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_ephemeralsharedsecret() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.ephemeralsharedsecret_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_ephemeralsharedsecret() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.ephemeralSharedSecret)
+  if (!_internal_has_ephemeralsharedsecret()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.ephemeralsharedsecret_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeralsharedsecret_.IsDefault()) {
+    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret) {
+  if (ephemeralsharedsecret != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.ephemeralsharedsecret_.SetAllocated(ephemeralsharedsecret, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeralsharedsecret_.IsDefault()) {
+    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ephemeralSharedSecret)
+}
+
+// optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
+inline bool ContextInfo::_internal_has_externaladreply() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.externaladreply_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_externaladreply() const {
+  return _internal_has_externaladreply();
+}
+inline void ContextInfo::clear_externaladreply() {
+  if (_impl_.externaladreply_ != nullptr) _impl_.externaladreply_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::_internal_externaladreply() const {
+  const ::proto::ContextInfo_ExternalAdReplyInfo* p = _impl_.externaladreply_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo_ExternalAdReplyInfo&>(
+      ::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_);
+}
+inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::externaladreply() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.externalAdReply)
+  return _internal_externaladreply();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_externaladreply(
+    ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externaladreply_);
+  }
+  _impl_.externaladreply_ = externaladreply;
+  if (externaladreply) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.externalAdReply)
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::release_externaladreply() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_;
+  _impl_.externaladreply_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::unsafe_arena_release_externaladreply() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.externalAdReply)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_;
+  _impl_.externaladreply_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::_internal_mutable_externaladreply() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.externaladreply_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(GetArenaForAllocation());
+    _impl_.externaladreply_ = p;
+  }
+  return _impl_.externaladreply_;
+}
+inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::mutable_externaladreply() {
+  ::proto::ContextInfo_ExternalAdReplyInfo* _msg = _internal_mutable_externaladreply();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.externalAdReply)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.externaladreply_;
+  }
+  if (externaladreply) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externaladreply);
+    if (message_arena != submessage_arena) {
+      externaladreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, externaladreply, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.externaladreply_ = externaladreply;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.externalAdReply)
+}
+
+// optional string entryPointConversionSource = 29;
+inline bool ContextInfo::_internal_has_entrypointconversionsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_entrypointconversionsource() const {
+  return _internal_has_entrypointconversionsource();
+}
+inline void ContextInfo::clear_entrypointconversionsource() {
+  _impl_.entrypointconversionsource_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& ContextInfo::entrypointconversionsource() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionSource)
+  return _internal_entrypointconversionsource();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_entrypointconversionsource(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.entrypointconversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionSource)
+}
+inline std::string* ContextInfo::mutable_entrypointconversionsource() {
+  std::string* _s = _internal_mutable_entrypointconversionsource();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionSource)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_entrypointconversionsource() const {
+  return _impl_.entrypointconversionsource_.Get();
+}
+inline void ContextInfo::_internal_set_entrypointconversionsource(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.entrypointconversionsource_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_entrypointconversionsource() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.entrypointconversionsource_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_entrypointconversionsource() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionSource)
+  if (!_internal_has_entrypointconversionsource()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.entrypointconversionsource_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.entrypointconversionsource_.IsDefault()) {
+    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_entrypointconversionsource(std::string* entrypointconversionsource) {
+  if (entrypointconversionsource != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.entrypointconversionsource_.SetAllocated(entrypointconversionsource, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.entrypointconversionsource_.IsDefault()) {
+    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionSource)
+}
+
+// optional string entryPointConversionApp = 30;
+inline bool ContextInfo::_internal_has_entrypointconversionapp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_entrypointconversionapp() const {
+  return _internal_has_entrypointconversionapp();
+}
+inline void ContextInfo::clear_entrypointconversionapp() {
+  _impl_.entrypointconversionapp_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& ContextInfo::entrypointconversionapp() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionApp)
+  return _internal_entrypointconversionapp();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_entrypointconversionapp(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.entrypointconversionapp_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionApp)
+}
+inline std::string* ContextInfo::mutable_entrypointconversionapp() {
+  std::string* _s = _internal_mutable_entrypointconversionapp();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionApp)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_entrypointconversionapp() const {
+  return _impl_.entrypointconversionapp_.Get();
+}
+inline void ContextInfo::_internal_set_entrypointconversionapp(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.entrypointconversionapp_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_entrypointconversionapp() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.entrypointconversionapp_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_entrypointconversionapp() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionApp)
+  if (!_internal_has_entrypointconversionapp()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.entrypointconversionapp_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.entrypointconversionapp_.IsDefault()) {
+    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_entrypointconversionapp(std::string* entrypointconversionapp) {
+  if (entrypointconversionapp != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.entrypointconversionapp_.SetAllocated(entrypointconversionapp, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.entrypointconversionapp_.IsDefault()) {
+    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionApp)
+}
+
+// optional uint32 entryPointConversionDelaySeconds = 31;
+inline bool ContextInfo::_internal_has_entrypointconversiondelayseconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_entrypointconversiondelayseconds() const {
+  return _internal_has_entrypointconversiondelayseconds();
+}
+inline void ContextInfo::clear_entrypointconversiondelayseconds() {
+  _impl_.entrypointconversiondelayseconds_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline uint32_t ContextInfo::_internal_entrypointconversiondelayseconds() const {
+  return _impl_.entrypointconversiondelayseconds_;
+}
+inline uint32_t ContextInfo::entrypointconversiondelayseconds() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionDelaySeconds)
+  return _internal_entrypointconversiondelayseconds();
+}
+inline void ContextInfo::_internal_set_entrypointconversiondelayseconds(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.entrypointconversiondelayseconds_ = value;
+}
+inline void ContextInfo::set_entrypointconversiondelayseconds(uint32_t value) {
+  _internal_set_entrypointconversiondelayseconds(value);
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionDelaySeconds)
+}
+
+// optional .proto.DisappearingMode disappearingMode = 32;
+inline bool ContextInfo::_internal_has_disappearingmode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_disappearingmode() const {
+  return _internal_has_disappearingmode();
+}
+inline void ContextInfo::clear_disappearingmode() {
+  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline const ::proto::DisappearingMode& ContextInfo::_internal_disappearingmode() const {
+  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
+      ::proto::_DisappearingMode_default_instance_);
+}
+inline const ::proto::DisappearingMode& ContextInfo::disappearingmode() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.disappearingMode)
+  return _internal_disappearingmode();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_disappearingmode(
+    ::proto::DisappearingMode* disappearingmode) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  if (disappearingmode) {
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.disappearingMode)
+}
+inline ::proto::DisappearingMode* ContextInfo::release_disappearingmode() {
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::DisappearingMode* ContextInfo::unsafe_arena_release_disappearingmode() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.disappearingMode)
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+  return temp;
+}
+inline ::proto::DisappearingMode* ContextInfo::_internal_mutable_disappearingmode() {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  if (_impl_.disappearingmode_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
+    _impl_.disappearingmode_ = p;
+  }
+  return _impl_.disappearingmode_;
+}
+inline ::proto::DisappearingMode* ContextInfo::mutable_disappearingmode() {
+  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.disappearingMode)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.disappearingmode_;
+  }
+  if (disappearingmode) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
+    if (message_arena != submessage_arena) {
+      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, disappearingmode, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.disappearingMode)
+}
+
+// optional .proto.ActionLink actionLink = 33;
+inline bool ContextInfo::_internal_has_actionlink() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.actionlink_ != nullptr);
+  return value;
+}
+inline bool ContextInfo::has_actionlink() const {
+  return _internal_has_actionlink();
+}
+inline void ContextInfo::clear_actionlink() {
+  if (_impl_.actionlink_ != nullptr) _impl_.actionlink_->Clear();
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline const ::proto::ActionLink& ContextInfo::_internal_actionlink() const {
+  const ::proto::ActionLink* p = _impl_.actionlink_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ActionLink&>(
+      ::proto::_ActionLink_default_instance_);
+}
+inline const ::proto::ActionLink& ContextInfo::actionlink() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.actionLink)
+  return _internal_actionlink();
+}
+inline void ContextInfo::unsafe_arena_set_allocated_actionlink(
+    ::proto::ActionLink* actionlink) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.actionlink_);
+  }
+  _impl_.actionlink_ = actionlink;
+  if (actionlink) {
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.actionLink)
+}
+inline ::proto::ActionLink* ContextInfo::release_actionlink() {
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::ActionLink* temp = _impl_.actionlink_;
+  _impl_.actionlink_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ActionLink* ContextInfo::unsafe_arena_release_actionlink() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.actionLink)
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::ActionLink* temp = _impl_.actionlink_;
+  _impl_.actionlink_ = nullptr;
+  return temp;
+}
+inline ::proto::ActionLink* ContextInfo::_internal_mutable_actionlink() {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  if (_impl_.actionlink_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ActionLink>(GetArenaForAllocation());
+    _impl_.actionlink_ = p;
+  }
+  return _impl_.actionlink_;
+}
+inline ::proto::ActionLink* ContextInfo::mutable_actionlink() {
+  ::proto::ActionLink* _msg = _internal_mutable_actionlink();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.actionLink)
+  return _msg;
+}
+inline void ContextInfo::set_allocated_actionlink(::proto::ActionLink* actionlink) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.actionlink_;
+  }
+  if (actionlink) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(actionlink);
+    if (message_arena != submessage_arena) {
+      actionlink = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, actionlink, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  _impl_.actionlink_ = actionlink;
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.actionLink)
+}
+
+// optional string groupSubject = 34;
+inline bool ContextInfo::_internal_has_groupsubject() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_groupsubject() const {
+  return _internal_has_groupsubject();
+}
+inline void ContextInfo::clear_groupsubject() {
+  _impl_.groupsubject_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& ContextInfo::groupsubject() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.groupSubject)
+  return _internal_groupsubject();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_groupsubject(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.groupsubject_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.groupSubject)
+}
+inline std::string* ContextInfo::mutable_groupsubject() {
+  std::string* _s = _internal_mutable_groupsubject();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.groupSubject)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_groupsubject() const {
+  return _impl_.groupsubject_.Get();
+}
+inline void ContextInfo::_internal_set_groupsubject(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.groupsubject_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_groupsubject() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.groupsubject_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_groupsubject() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.groupSubject)
+  if (!_internal_has_groupsubject()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.groupsubject_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupsubject_.IsDefault()) {
+    _impl_.groupsubject_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_groupsubject(std::string* groupsubject) {
+  if (groupsubject != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.groupsubject_.SetAllocated(groupsubject, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupsubject_.IsDefault()) {
+    _impl_.groupsubject_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.groupSubject)
+}
+
+// optional string parentGroupJid = 35;
+inline bool ContextInfo::_internal_has_parentgroupjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ContextInfo::has_parentgroupjid() const {
+  return _internal_has_parentgroupjid();
+}
+inline void ContextInfo::clear_parentgroupjid() {
+  _impl_.parentgroupjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& ContextInfo::parentgroupjid() const {
+  // @@protoc_insertion_point(field_get:proto.ContextInfo.parentGroupJid)
+  return _internal_parentgroupjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContextInfo::set_parentgroupjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.parentgroupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ContextInfo.parentGroupJid)
+}
+inline std::string* ContextInfo::mutable_parentgroupjid() {
+  std::string* _s = _internal_mutable_parentgroupjid();
+  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.parentGroupJid)
+  return _s;
+}
+inline const std::string& ContextInfo::_internal_parentgroupjid() const {
+  return _impl_.parentgroupjid_.Get();
+}
+inline void ContextInfo::_internal_set_parentgroupjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.parentgroupjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ContextInfo::_internal_mutable_parentgroupjid() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.parentgroupjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ContextInfo::release_parentgroupjid() {
+  // @@protoc_insertion_point(field_release:proto.ContextInfo.parentGroupJid)
+  if (!_internal_has_parentgroupjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.parentgroupjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parentgroupjid_.IsDefault()) {
+    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ContextInfo::set_allocated_parentgroupjid(std::string* parentgroupjid) {
+  if (parentgroupjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.parentgroupjid_.SetAllocated(parentgroupjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parentgroupjid_.IsDefault()) {
+    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.parentGroupJid)
+}
+
+// -------------------------------------------------------------------
+
+// Conversation
+
+// required string id = 1;
+inline bool Conversation::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Conversation::has_id() const {
+  return _internal_has_id();
+}
+inline void Conversation::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Conversation::id() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.id)
+}
+inline std::string* Conversation::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.id)
+  return _s;
+}
+inline const std::string& Conversation::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void Conversation::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_id() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.id)
+}
+
+// repeated .proto.HistorySyncMsg messages = 2;
+inline int Conversation::_internal_messages_size() const {
+  return _impl_.messages_.size();
+}
+inline int Conversation::messages_size() const {
+  return _internal_messages_size();
+}
+inline void Conversation::clear_messages() {
+  _impl_.messages_.Clear();
+}
+inline ::proto::HistorySyncMsg* Conversation::mutable_messages(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.messages)
+  return _impl_.messages_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >*
+Conversation::mutable_messages() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Conversation.messages)
+  return &_impl_.messages_;
+}
+inline const ::proto::HistorySyncMsg& Conversation::_internal_messages(int index) const {
+  return _impl_.messages_.Get(index);
+}
+inline const ::proto::HistorySyncMsg& Conversation::messages(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.messages)
+  return _internal_messages(index);
+}
+inline ::proto::HistorySyncMsg* Conversation::_internal_add_messages() {
+  return _impl_.messages_.Add();
+}
+inline ::proto::HistorySyncMsg* Conversation::add_messages() {
+  ::proto::HistorySyncMsg* _add = _internal_add_messages();
+  // @@protoc_insertion_point(field_add:proto.Conversation.messages)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >&
+Conversation::messages() const {
+  // @@protoc_insertion_point(field_list:proto.Conversation.messages)
+  return _impl_.messages_;
+}
+
+// optional string newJid = 3;
+inline bool Conversation::_internal_has_newjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Conversation::has_newjid() const {
+  return _internal_has_newjid();
+}
+inline void Conversation::clear_newjid() {
+  _impl_.newjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Conversation::newjid() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.newJid)
+  return _internal_newjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_newjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.newjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.newJid)
+}
+inline std::string* Conversation::mutable_newjid() {
+  std::string* _s = _internal_mutable_newjid();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.newJid)
+  return _s;
+}
+inline const std::string& Conversation::_internal_newjid() const {
+  return _impl_.newjid_.Get();
+}
+inline void Conversation::_internal_set_newjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.newjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_newjid() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.newjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_newjid() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.newJid)
+  if (!_internal_has_newjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.newjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.newjid_.IsDefault()) {
+    _impl_.newjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_newjid(std::string* newjid) {
+  if (newjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.newjid_.SetAllocated(newjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.newjid_.IsDefault()) {
+    _impl_.newjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.newJid)
+}
+
+// optional string oldJid = 4;
+inline bool Conversation::_internal_has_oldjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Conversation::has_oldjid() const {
+  return _internal_has_oldjid();
+}
+inline void Conversation::clear_oldjid() {
+  _impl_.oldjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Conversation::oldjid() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.oldJid)
+  return _internal_oldjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_oldjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.oldjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.oldJid)
+}
+inline std::string* Conversation::mutable_oldjid() {
+  std::string* _s = _internal_mutable_oldjid();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.oldJid)
+  return _s;
+}
+inline const std::string& Conversation::_internal_oldjid() const {
+  return _impl_.oldjid_.Get();
+}
+inline void Conversation::_internal_set_oldjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.oldjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_oldjid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.oldjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_oldjid() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.oldJid)
+  if (!_internal_has_oldjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.oldjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.oldjid_.IsDefault()) {
+    _impl_.oldjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_oldjid(std::string* oldjid) {
+  if (oldjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.oldjid_.SetAllocated(oldjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.oldjid_.IsDefault()) {
+    _impl_.oldjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.oldJid)
+}
+
+// optional uint64 lastMsgTimestamp = 5;
+inline bool Conversation::_internal_has_lastmsgtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Conversation::has_lastmsgtimestamp() const {
+  return _internal_has_lastmsgtimestamp();
+}
+inline void Conversation::clear_lastmsgtimestamp() {
+  _impl_.lastmsgtimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline uint64_t Conversation::_internal_lastmsgtimestamp() const {
+  return _impl_.lastmsgtimestamp_;
+}
+inline uint64_t Conversation::lastmsgtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.lastMsgTimestamp)
+  return _internal_lastmsgtimestamp();
+}
+inline void Conversation::_internal_set_lastmsgtimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.lastmsgtimestamp_ = value;
+}
+inline void Conversation::set_lastmsgtimestamp(uint64_t value) {
+  _internal_set_lastmsgtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.lastMsgTimestamp)
+}
+
+// optional uint32 unreadCount = 6;
+inline bool Conversation::_internal_has_unreadcount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool Conversation::has_unreadcount() const {
+  return _internal_has_unreadcount();
+}
+inline void Conversation::clear_unreadcount() {
+  _impl_.unreadcount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline uint32_t Conversation::_internal_unreadcount() const {
+  return _impl_.unreadcount_;
+}
+inline uint32_t Conversation::unreadcount() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.unreadCount)
+  return _internal_unreadcount();
+}
+inline void Conversation::_internal_set_unreadcount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.unreadcount_ = value;
+}
+inline void Conversation::set_unreadcount(uint32_t value) {
+  _internal_set_unreadcount(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.unreadCount)
+}
+
+// optional bool readOnly = 7;
+inline bool Conversation::_internal_has_readonly() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool Conversation::has_readonly() const {
+  return _internal_has_readonly();
+}
+inline void Conversation::clear_readonly() {
+  _impl_.readonly_ = false;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline bool Conversation::_internal_readonly() const {
+  return _impl_.readonly_;
+}
+inline bool Conversation::readonly() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.readOnly)
+  return _internal_readonly();
+}
+inline void Conversation::_internal_set_readonly(bool value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.readonly_ = value;
+}
+inline void Conversation::set_readonly(bool value) {
+  _internal_set_readonly(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.readOnly)
+}
+
+// optional bool endOfHistoryTransfer = 8;
+inline bool Conversation::_internal_has_endofhistorytransfer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool Conversation::has_endofhistorytransfer() const {
+  return _internal_has_endofhistorytransfer();
+}
+inline void Conversation::clear_endofhistorytransfer() {
+  _impl_.endofhistorytransfer_ = false;
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline bool Conversation::_internal_endofhistorytransfer() const {
+  return _impl_.endofhistorytransfer_;
+}
+inline bool Conversation::endofhistorytransfer() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransfer)
+  return _internal_endofhistorytransfer();
+}
+inline void Conversation::_internal_set_endofhistorytransfer(bool value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.endofhistorytransfer_ = value;
+}
+inline void Conversation::set_endofhistorytransfer(bool value) {
+  _internal_set_endofhistorytransfer(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransfer)
+}
+
+// optional uint32 ephemeralExpiration = 9;
+inline bool Conversation::_internal_has_ephemeralexpiration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool Conversation::has_ephemeralexpiration() const {
+  return _internal_has_ephemeralexpiration();
+}
+inline void Conversation::clear_ephemeralexpiration() {
+  _impl_.ephemeralexpiration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline uint32_t Conversation::_internal_ephemeralexpiration() const {
+  return _impl_.ephemeralexpiration_;
+}
+inline uint32_t Conversation::ephemeralexpiration() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralExpiration)
+  return _internal_ephemeralexpiration();
+}
+inline void Conversation::_internal_set_ephemeralexpiration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.ephemeralexpiration_ = value;
+}
+inline void Conversation::set_ephemeralexpiration(uint32_t value) {
+  _internal_set_ephemeralexpiration(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralExpiration)
+}
+
+// optional int64 ephemeralSettingTimestamp = 10;
+inline bool Conversation::_internal_has_ephemeralsettingtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool Conversation::has_ephemeralsettingtimestamp() const {
+  return _internal_has_ephemeralsettingtimestamp();
+}
+inline void Conversation::clear_ephemeralsettingtimestamp() {
+  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline int64_t Conversation::_internal_ephemeralsettingtimestamp() const {
+  return _impl_.ephemeralsettingtimestamp_;
+}
+inline int64_t Conversation::ephemeralsettingtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralSettingTimestamp)
+  return _internal_ephemeralsettingtimestamp();
+}
+inline void Conversation::_internal_set_ephemeralsettingtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.ephemeralsettingtimestamp_ = value;
+}
+inline void Conversation::set_ephemeralsettingtimestamp(int64_t value) {
+  _internal_set_ephemeralsettingtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralSettingTimestamp)
+}
+
+// optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
+inline bool Conversation::_internal_has_endofhistorytransfertype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool Conversation::has_endofhistorytransfertype() const {
+  return _internal_has_endofhistorytransfertype();
+}
+inline void Conversation::clear_endofhistorytransfertype() {
+  _impl_.endofhistorytransfertype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline ::proto::Conversation_EndOfHistoryTransferType Conversation::_internal_endofhistorytransfertype() const {
+  return static_cast< ::proto::Conversation_EndOfHistoryTransferType >(_impl_.endofhistorytransfertype_);
+}
+inline ::proto::Conversation_EndOfHistoryTransferType Conversation::endofhistorytransfertype() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransferType)
+  return _internal_endofhistorytransfertype();
+}
+inline void Conversation::_internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) {
+  assert(::proto::Conversation_EndOfHistoryTransferType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.endofhistorytransfertype_ = value;
+}
+inline void Conversation::set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) {
+  _internal_set_endofhistorytransfertype(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransferType)
+}
+
+// optional uint64 conversationTimestamp = 12;
+inline bool Conversation::_internal_has_conversationtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  return value;
+}
+inline bool Conversation::has_conversationtimestamp() const {
+  return _internal_has_conversationtimestamp();
+}
+inline void Conversation::clear_conversationtimestamp() {
+  _impl_.conversationtimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline uint64_t Conversation::_internal_conversationtimestamp() const {
+  return _impl_.conversationtimestamp_;
+}
+inline uint64_t Conversation::conversationtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.conversationTimestamp)
+  return _internal_conversationtimestamp();
+}
+inline void Conversation::_internal_set_conversationtimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00800000u;
+  _impl_.conversationtimestamp_ = value;
+}
+inline void Conversation::set_conversationtimestamp(uint64_t value) {
+  _internal_set_conversationtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.conversationTimestamp)
+}
+
+// optional string name = 13;
+inline bool Conversation::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Conversation::has_name() const {
+  return _internal_has_name();
+}
+inline void Conversation::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Conversation::name() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.name)
+}
+inline std::string* Conversation::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.name)
+  return _s;
+}
+inline const std::string& Conversation::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Conversation::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.name)
+}
+
+// optional string pHash = 14;
+inline bool Conversation::_internal_has_phash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Conversation::has_phash() const {
+  return _internal_has_phash();
+}
+inline void Conversation::clear_phash() {
+  _impl_.phash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Conversation::phash() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.pHash)
+  return _internal_phash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_phash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.phash_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.pHash)
+}
+inline std::string* Conversation::mutable_phash() {
+  std::string* _s = _internal_mutable_phash();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.pHash)
+  return _s;
+}
+inline const std::string& Conversation::_internal_phash() const {
+  return _impl_.phash_.Get();
+}
+inline void Conversation::_internal_set_phash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.phash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_phash() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.phash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_phash() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.pHash)
+  if (!_internal_has_phash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.phash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phash_.IsDefault()) {
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_phash(std::string* phash) {
+  if (phash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.phash_.SetAllocated(phash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phash_.IsDefault()) {
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pHash)
+}
+
+// optional bool notSpam = 15;
+inline bool Conversation::_internal_has_notspam() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool Conversation::has_notspam() const {
+  return _internal_has_notspam();
+}
+inline void Conversation::clear_notspam() {
+  _impl_.notspam_ = false;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline bool Conversation::_internal_notspam() const {
+  return _impl_.notspam_;
+}
+inline bool Conversation::notspam() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.notSpam)
+  return _internal_notspam();
+}
+inline void Conversation::_internal_set_notspam(bool value) {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.notspam_ = value;
+}
+inline void Conversation::set_notspam(bool value) {
+  _internal_set_notspam(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.notSpam)
+}
+
+// optional bool archived = 16;
+inline bool Conversation::_internal_has_archived() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool Conversation::has_archived() const {
+  return _internal_has_archived();
+}
+inline void Conversation::clear_archived() {
+  _impl_.archived_ = false;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline bool Conversation::_internal_archived() const {
+  return _impl_.archived_;
+}
+inline bool Conversation::archived() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.archived)
+  return _internal_archived();
+}
+inline void Conversation::_internal_set_archived(bool value) {
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.archived_ = value;
+}
+inline void Conversation::set_archived(bool value) {
+  _internal_set_archived(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.archived)
+}
+
+// optional .proto.DisappearingMode disappearingMode = 17;
+inline bool Conversation::_internal_has_disappearingmode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
+  return value;
+}
+inline bool Conversation::has_disappearingmode() const {
+  return _internal_has_disappearingmode();
+}
+inline void Conversation::clear_disappearingmode() {
+  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::DisappearingMode& Conversation::_internal_disappearingmode() const {
+  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
+      ::proto::_DisappearingMode_default_instance_);
+}
+inline const ::proto::DisappearingMode& Conversation::disappearingmode() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.disappearingMode)
+  return _internal_disappearingmode();
+}
+inline void Conversation::unsafe_arena_set_allocated_disappearingmode(
+    ::proto::DisappearingMode* disappearingmode) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  if (disappearingmode) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.disappearingMode)
+}
+inline ::proto::DisappearingMode* Conversation::release_disappearingmode() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::DisappearingMode* Conversation::unsafe_arena_release_disappearingmode() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.disappearingMode)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+  return temp;
+}
+inline ::proto::DisappearingMode* Conversation::_internal_mutable_disappearingmode() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.disappearingmode_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
+    _impl_.disappearingmode_ = p;
+  }
+  return _impl_.disappearingmode_;
+}
+inline ::proto::DisappearingMode* Conversation::mutable_disappearingmode() {
+  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.disappearingMode)
+  return _msg;
+}
+inline void Conversation::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.disappearingmode_;
+  }
+  if (disappearingmode) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
+    if (message_arena != submessage_arena) {
+      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, disappearingmode, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.disappearingMode)
+}
+
+// optional uint32 unreadMentionCount = 18;
+inline bool Conversation::_internal_has_unreadmentioncount() const {
+  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_unreadmentioncount() const {
+  return _internal_has_unreadmentioncount();
+}
+inline void Conversation::clear_unreadmentioncount() {
+  _impl_.unreadmentioncount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x01000000u;
+}
+inline uint32_t Conversation::_internal_unreadmentioncount() const {
+  return _impl_.unreadmentioncount_;
+}
+inline uint32_t Conversation::unreadmentioncount() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.unreadMentionCount)
+  return _internal_unreadmentioncount();
+}
+inline void Conversation::_internal_set_unreadmentioncount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x01000000u;
+  _impl_.unreadmentioncount_ = value;
+}
+inline void Conversation::set_unreadmentioncount(uint32_t value) {
+  _internal_set_unreadmentioncount(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.unreadMentionCount)
+}
+
+// optional bool markedAsUnread = 19;
+inline bool Conversation::_internal_has_markedasunread() const {
+  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_markedasunread() const {
+  return _internal_has_markedasunread();
+}
+inline void Conversation::clear_markedasunread() {
+  _impl_.markedasunread_ = false;
+  _impl_._has_bits_[0] &= ~0x20000000u;
+}
+inline bool Conversation::_internal_markedasunread() const {
+  return _impl_.markedasunread_;
+}
+inline bool Conversation::markedasunread() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.markedAsUnread)
+  return _internal_markedasunread();
+}
+inline void Conversation::_internal_set_markedasunread(bool value) {
+  _impl_._has_bits_[0] |= 0x20000000u;
+  _impl_.markedasunread_ = value;
+}
+inline void Conversation::set_markedasunread(bool value) {
+  _internal_set_markedasunread(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.markedAsUnread)
+}
+
+// repeated .proto.GroupParticipant participant = 20;
+inline int Conversation::_internal_participant_size() const {
+  return _impl_.participant_.size();
+}
+inline int Conversation::participant_size() const {
+  return _internal_participant_size();
+}
+inline void Conversation::clear_participant() {
+  _impl_.participant_.Clear();
+}
+inline ::proto::GroupParticipant* Conversation::mutable_participant(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.participant)
+  return _impl_.participant_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >*
+Conversation::mutable_participant() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Conversation.participant)
+  return &_impl_.participant_;
+}
+inline const ::proto::GroupParticipant& Conversation::_internal_participant(int index) const {
+  return _impl_.participant_.Get(index);
+}
+inline const ::proto::GroupParticipant& Conversation::participant(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.participant)
+  return _internal_participant(index);
+}
+inline ::proto::GroupParticipant* Conversation::_internal_add_participant() {
+  return _impl_.participant_.Add();
+}
+inline ::proto::GroupParticipant* Conversation::add_participant() {
+  ::proto::GroupParticipant* _add = _internal_add_participant();
+  // @@protoc_insertion_point(field_add:proto.Conversation.participant)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >&
+Conversation::participant() const {
+  // @@protoc_insertion_point(field_list:proto.Conversation.participant)
+  return _impl_.participant_;
+}
+
+// optional bytes tcToken = 21;
+inline bool Conversation::_internal_has_tctoken() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Conversation::has_tctoken() const {
+  return _internal_has_tctoken();
+}
+inline void Conversation::clear_tctoken() {
+  _impl_.tctoken_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Conversation::tctoken() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.tcToken)
+  return _internal_tctoken();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_tctoken(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.tctoken_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.tcToken)
+}
+inline std::string* Conversation::mutable_tctoken() {
+  std::string* _s = _internal_mutable_tctoken();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.tcToken)
+  return _s;
+}
+inline const std::string& Conversation::_internal_tctoken() const {
+  return _impl_.tctoken_.Get();
+}
+inline void Conversation::_internal_set_tctoken(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.tctoken_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_tctoken() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.tctoken_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_tctoken() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.tcToken)
+  if (!_internal_has_tctoken()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.tctoken_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tctoken_.IsDefault()) {
+    _impl_.tctoken_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_tctoken(std::string* tctoken) {
+  if (tctoken != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.tctoken_.SetAllocated(tctoken, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tctoken_.IsDefault()) {
+    _impl_.tctoken_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.tcToken)
+}
+
+// optional uint64 tcTokenTimestamp = 22;
+inline bool Conversation::_internal_has_tctokentimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_tctokentimestamp() const {
+  return _internal_has_tctokentimestamp();
+}
+inline void Conversation::clear_tctokentimestamp() {
+  _impl_.tctokentimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x04000000u;
+}
+inline uint64_t Conversation::_internal_tctokentimestamp() const {
+  return _impl_.tctokentimestamp_;
+}
+inline uint64_t Conversation::tctokentimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenTimestamp)
+  return _internal_tctokentimestamp();
+}
+inline void Conversation::_internal_set_tctokentimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x04000000u;
+  _impl_.tctokentimestamp_ = value;
+}
+inline void Conversation::set_tctokentimestamp(uint64_t value) {
+  _internal_set_tctokentimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenTimestamp)
+}
+
+// optional bytes contactPrimaryIdentityKey = 23;
+inline bool Conversation::_internal_has_contactprimaryidentitykey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Conversation::has_contactprimaryidentitykey() const {
+  return _internal_has_contactprimaryidentitykey();
+}
+inline void Conversation::clear_contactprimaryidentitykey() {
+  _impl_.contactprimaryidentitykey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Conversation::contactprimaryidentitykey() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.contactPrimaryIdentityKey)
+  return _internal_contactprimaryidentitykey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.contactprimaryidentitykey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.contactPrimaryIdentityKey)
+}
+inline std::string* Conversation::mutable_contactprimaryidentitykey() {
+  std::string* _s = _internal_mutable_contactprimaryidentitykey();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.contactPrimaryIdentityKey)
+  return _s;
+}
+inline const std::string& Conversation::_internal_contactprimaryidentitykey() const {
+  return _impl_.contactprimaryidentitykey_.Get();
+}
+inline void Conversation::_internal_set_contactprimaryidentitykey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.contactprimaryidentitykey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_contactprimaryidentitykey() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.contactprimaryidentitykey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_contactprimaryidentitykey() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.contactPrimaryIdentityKey)
+  if (!_internal_has_contactprimaryidentitykey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.contactprimaryidentitykey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.contactprimaryidentitykey_.IsDefault()) {
+    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey) {
+  if (contactprimaryidentitykey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.contactprimaryidentitykey_.SetAllocated(contactprimaryidentitykey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.contactprimaryidentitykey_.IsDefault()) {
+    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.contactPrimaryIdentityKey)
+}
+
+// optional uint32 pinned = 24;
+inline bool Conversation::_internal_has_pinned() const {
+  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_pinned() const {
+  return _internal_has_pinned();
+}
+inline void Conversation::clear_pinned() {
+  _impl_.pinned_ = 0u;
+  _impl_._has_bits_[0] &= ~0x02000000u;
+}
+inline uint32_t Conversation::_internal_pinned() const {
+  return _impl_.pinned_;
+}
+inline uint32_t Conversation::pinned() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.pinned)
+  return _internal_pinned();
+}
+inline void Conversation::_internal_set_pinned(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x02000000u;
+  _impl_.pinned_ = value;
+}
+inline void Conversation::set_pinned(uint32_t value) {
+  _internal_set_pinned(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.pinned)
+}
+
+// optional uint64 muteEndTime = 25;
+inline bool Conversation::_internal_has_muteendtime() const {
+  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_muteendtime() const {
+  return _internal_has_muteendtime();
+}
+inline void Conversation::clear_muteendtime() {
+  _impl_.muteendtime_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x08000000u;
+}
+inline uint64_t Conversation::_internal_muteendtime() const {
+  return _impl_.muteendtime_;
+}
+inline uint64_t Conversation::muteendtime() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.muteEndTime)
+  return _internal_muteendtime();
+}
+inline void Conversation::_internal_set_muteendtime(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x08000000u;
+  _impl_.muteendtime_ = value;
+}
+inline void Conversation::set_muteendtime(uint64_t value) {
+  _internal_set_muteendtime(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.muteEndTime)
+}
+
+// optional .proto.WallpaperSettings wallpaper = 26;
+inline bool Conversation::_internal_has_wallpaper() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.wallpaper_ != nullptr);
+  return value;
+}
+inline bool Conversation::has_wallpaper() const {
+  return _internal_has_wallpaper();
+}
+inline void Conversation::clear_wallpaper() {
+  if (_impl_.wallpaper_ != nullptr) _impl_.wallpaper_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::WallpaperSettings& Conversation::_internal_wallpaper() const {
+  const ::proto::WallpaperSettings* p = _impl_.wallpaper_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
+      ::proto::_WallpaperSettings_default_instance_);
+}
+inline const ::proto::WallpaperSettings& Conversation::wallpaper() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.wallpaper)
+  return _internal_wallpaper();
+}
+inline void Conversation::unsafe_arena_set_allocated_wallpaper(
+    ::proto::WallpaperSettings* wallpaper) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.wallpaper_);
+  }
+  _impl_.wallpaper_ = wallpaper;
+  if (wallpaper) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.wallpaper)
+}
+inline ::proto::WallpaperSettings* Conversation::release_wallpaper() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::WallpaperSettings* temp = _impl_.wallpaper_;
+  _impl_.wallpaper_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::WallpaperSettings* Conversation::unsafe_arena_release_wallpaper() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.wallpaper)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::WallpaperSettings* temp = _impl_.wallpaper_;
+  _impl_.wallpaper_ = nullptr;
+  return temp;
+}
+inline ::proto::WallpaperSettings* Conversation::_internal_mutable_wallpaper() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.wallpaper_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
+    _impl_.wallpaper_ = p;
+  }
+  return _impl_.wallpaper_;
+}
+inline ::proto::WallpaperSettings* Conversation::mutable_wallpaper() {
+  ::proto::WallpaperSettings* _msg = _internal_mutable_wallpaper();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.wallpaper)
+  return _msg;
+}
+inline void Conversation::set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.wallpaper_;
+  }
+  if (wallpaper) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wallpaper);
+    if (message_arena != submessage_arena) {
+      wallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, wallpaper, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.wallpaper_ = wallpaper;
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.wallpaper)
+}
+
+// optional .proto.MediaVisibility mediaVisibility = 27;
+inline bool Conversation::_internal_has_mediavisibility() const {
+  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_mediavisibility() const {
+  return _internal_has_mediavisibility();
+}
+inline void Conversation::clear_mediavisibility() {
+  _impl_.mediavisibility_ = 0;
+  _impl_._has_bits_[0] &= ~0x10000000u;
+}
+inline ::proto::MediaVisibility Conversation::_internal_mediavisibility() const {
+  return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_);
+}
+inline ::proto::MediaVisibility Conversation::mediavisibility() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.mediaVisibility)
+  return _internal_mediavisibility();
+}
+inline void Conversation::_internal_set_mediavisibility(::proto::MediaVisibility value) {
+  assert(::proto::MediaVisibility_IsValid(value));
+  _impl_._has_bits_[0] |= 0x10000000u;
+  _impl_.mediavisibility_ = value;
+}
+inline void Conversation::set_mediavisibility(::proto::MediaVisibility value) {
+  _internal_set_mediavisibility(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.mediaVisibility)
+}
+
+// optional uint64 tcTokenSenderTimestamp = 28;
+inline bool Conversation::_internal_has_tctokensendertimestamp() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Conversation::has_tctokensendertimestamp() const {
+  return _internal_has_tctokensendertimestamp();
+}
+inline void Conversation::clear_tctokensendertimestamp() {
+  _impl_.tctokensendertimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[1] &= ~0x00000002u;
+}
+inline uint64_t Conversation::_internal_tctokensendertimestamp() const {
+  return _impl_.tctokensendertimestamp_;
+}
+inline uint64_t Conversation::tctokensendertimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenSenderTimestamp)
+  return _internal_tctokensendertimestamp();
+}
+inline void Conversation::_internal_set_tctokensendertimestamp(uint64_t value) {
+  _impl_._has_bits_[1] |= 0x00000002u;
+  _impl_.tctokensendertimestamp_ = value;
+}
+inline void Conversation::set_tctokensendertimestamp(uint64_t value) {
+  _internal_set_tctokensendertimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenSenderTimestamp)
+}
+
+// optional bool suspended = 29;
+inline bool Conversation::_internal_has_suspended() const {
+  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_suspended() const {
+  return _internal_has_suspended();
+}
+inline void Conversation::clear_suspended() {
+  _impl_.suspended_ = false;
+  _impl_._has_bits_[0] &= ~0x40000000u;
+}
+inline bool Conversation::_internal_suspended() const {
+  return _impl_.suspended_;
+}
+inline bool Conversation::suspended() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.suspended)
+  return _internal_suspended();
+}
+inline void Conversation::_internal_set_suspended(bool value) {
+  _impl_._has_bits_[0] |= 0x40000000u;
+  _impl_.suspended_ = value;
+}
+inline void Conversation::set_suspended(bool value) {
+  _internal_set_suspended(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.suspended)
+}
+
+// optional bool terminated = 30;
+inline bool Conversation::_internal_has_terminated() const {
+  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
+  return value;
+}
+inline bool Conversation::has_terminated() const {
+  return _internal_has_terminated();
+}
+inline void Conversation::clear_terminated() {
+  _impl_.terminated_ = false;
+  _impl_._has_bits_[0] &= ~0x80000000u;
+}
+inline bool Conversation::_internal_terminated() const {
+  return _impl_.terminated_;
+}
+inline bool Conversation::terminated() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.terminated)
+  return _internal_terminated();
+}
+inline void Conversation::_internal_set_terminated(bool value) {
+  _impl_._has_bits_[0] |= 0x80000000u;
+  _impl_.terminated_ = value;
+}
+inline void Conversation::set_terminated(bool value) {
+  _internal_set_terminated(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.terminated)
+}
+
+// optional uint64 createdAt = 31;
+inline bool Conversation::_internal_has_createdat() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Conversation::has_createdat() const {
+  return _internal_has_createdat();
+}
+inline void Conversation::clear_createdat() {
+  _impl_.createdat_ = uint64_t{0u};
+  _impl_._has_bits_[1] &= ~0x00000004u;
+}
+inline uint64_t Conversation::_internal_createdat() const {
+  return _impl_.createdat_;
+}
+inline uint64_t Conversation::createdat() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.createdAt)
+  return _internal_createdat();
+}
+inline void Conversation::_internal_set_createdat(uint64_t value) {
+  _impl_._has_bits_[1] |= 0x00000004u;
+  _impl_.createdat_ = value;
+}
+inline void Conversation::set_createdat(uint64_t value) {
+  _internal_set_createdat(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.createdAt)
+}
+
+// optional string createdBy = 32;
+inline bool Conversation::_internal_has_createdby() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Conversation::has_createdby() const {
+  return _internal_has_createdby();
+}
+inline void Conversation::clear_createdby() {
+  _impl_.createdby_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Conversation::createdby() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.createdBy)
+  return _internal_createdby();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_createdby(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.createdby_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.createdBy)
+}
+inline std::string* Conversation::mutable_createdby() {
+  std::string* _s = _internal_mutable_createdby();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.createdBy)
+  return _s;
+}
+inline const std::string& Conversation::_internal_createdby() const {
+  return _impl_.createdby_.Get();
+}
+inline void Conversation::_internal_set_createdby(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.createdby_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_createdby() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.createdby_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_createdby() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.createdBy)
+  if (!_internal_has_createdby()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.createdby_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.createdby_.IsDefault()) {
+    _impl_.createdby_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_createdby(std::string* createdby) {
+  if (createdby != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.createdby_.SetAllocated(createdby, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.createdby_.IsDefault()) {
+    _impl_.createdby_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.createdBy)
+}
+
+// optional string description = 33;
+inline bool Conversation::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Conversation::has_description() const {
+  return _internal_has_description();
+}
+inline void Conversation::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& Conversation::description() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.description)
+}
+inline std::string* Conversation::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.description)
+  return _s;
+}
+inline const std::string& Conversation::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Conversation::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.description)
+}
+
+// optional bool support = 34;
+inline bool Conversation::_internal_has_support() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Conversation::has_support() const {
+  return _internal_has_support();
+}
+inline void Conversation::clear_support() {
+  _impl_.support_ = false;
+  _impl_._has_bits_[1] &= ~0x00000001u;
+}
+inline bool Conversation::_internal_support() const {
+  return _impl_.support_;
+}
+inline bool Conversation::support() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.support)
+  return _internal_support();
+}
+inline void Conversation::_internal_set_support(bool value) {
+  _impl_._has_bits_[1] |= 0x00000001u;
+  _impl_.support_ = value;
+}
+inline void Conversation::set_support(bool value) {
+  _internal_set_support(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.support)
+}
+
+// optional bool isParentGroup = 35;
+inline bool Conversation::_internal_has_isparentgroup() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Conversation::has_isparentgroup() const {
+  return _internal_has_isparentgroup();
+}
+inline void Conversation::clear_isparentgroup() {
+  _impl_.isparentgroup_ = false;
+  _impl_._has_bits_[1] &= ~0x00000008u;
+}
+inline bool Conversation::_internal_isparentgroup() const {
+  return _impl_.isparentgroup_;
+}
+inline bool Conversation::isparentgroup() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.isParentGroup)
+  return _internal_isparentgroup();
+}
+inline void Conversation::_internal_set_isparentgroup(bool value) {
+  _impl_._has_bits_[1] |= 0x00000008u;
+  _impl_.isparentgroup_ = value;
+}
+inline void Conversation::set_isparentgroup(bool value) {
+  _internal_set_isparentgroup(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.isParentGroup)
+}
+
+// optional bool isDefaultSubgroup = 36;
+inline bool Conversation::_internal_has_isdefaultsubgroup() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Conversation::has_isdefaultsubgroup() const {
+  return _internal_has_isdefaultsubgroup();
+}
+inline void Conversation::clear_isdefaultsubgroup() {
+  _impl_.isdefaultsubgroup_ = false;
+  _impl_._has_bits_[1] &= ~0x00000010u;
+}
+inline bool Conversation::_internal_isdefaultsubgroup() const {
+  return _impl_.isdefaultsubgroup_;
+}
+inline bool Conversation::isdefaultsubgroup() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.isDefaultSubgroup)
+  return _internal_isdefaultsubgroup();
+}
+inline void Conversation::_internal_set_isdefaultsubgroup(bool value) {
+  _impl_._has_bits_[1] |= 0x00000010u;
+  _impl_.isdefaultsubgroup_ = value;
+}
+inline void Conversation::set_isdefaultsubgroup(bool value) {
+  _internal_set_isdefaultsubgroup(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.isDefaultSubgroup)
+}
+
+// optional string parentGroupId = 37;
+inline bool Conversation::_internal_has_parentgroupid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Conversation::has_parentgroupid() const {
+  return _internal_has_parentgroupid();
+}
+inline void Conversation::clear_parentgroupid() {
+  _impl_.parentgroupid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& Conversation::parentgroupid() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.parentGroupId)
+  return _internal_parentgroupid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_parentgroupid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.parentgroupid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.parentGroupId)
+}
+inline std::string* Conversation::mutable_parentgroupid() {
+  std::string* _s = _internal_mutable_parentgroupid();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.parentGroupId)
+  return _s;
+}
+inline const std::string& Conversation::_internal_parentgroupid() const {
+  return _impl_.parentgroupid_.Get();
+}
+inline void Conversation::_internal_set_parentgroupid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.parentgroupid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_parentgroupid() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.parentgroupid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_parentgroupid() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.parentGroupId)
+  if (!_internal_has_parentgroupid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.parentgroupid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parentgroupid_.IsDefault()) {
+    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_parentgroupid(std::string* parentgroupid) {
+  if (parentgroupid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.parentgroupid_.SetAllocated(parentgroupid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parentgroupid_.IsDefault()) {
+    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.parentGroupId)
+}
+
+// optional string displayName = 38;
+inline bool Conversation::_internal_has_displayname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Conversation::has_displayname() const {
+  return _internal_has_displayname();
+}
+inline void Conversation::clear_displayname() {
+  _impl_.displayname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& Conversation::displayname() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.displayName)
+  return _internal_displayname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_displayname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.displayName)
+}
+inline std::string* Conversation::mutable_displayname() {
+  std::string* _s = _internal_mutable_displayname();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.displayName)
+  return _s;
+}
+inline const std::string& Conversation::_internal_displayname() const {
+  return _impl_.displayname_.Get();
+}
+inline void Conversation::_internal_set_displayname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.displayname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_displayname() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.displayname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_displayname() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.displayName)
+  if (!_internal_has_displayname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.displayname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_displayname(std::string* displayname) {
+  if (displayname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.displayName)
+}
+
+// optional string pnJid = 39;
+inline bool Conversation::_internal_has_pnjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Conversation::has_pnjid() const {
+  return _internal_has_pnjid();
+}
+inline void Conversation::clear_pnjid() {
+  _impl_.pnjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& Conversation::pnjid() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.pnJid)
+  return _internal_pnjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Conversation::set_pnjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.pnjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Conversation.pnJid)
+}
+inline std::string* Conversation::mutable_pnjid() {
+  std::string* _s = _internal_mutable_pnjid();
+  // @@protoc_insertion_point(field_mutable:proto.Conversation.pnJid)
+  return _s;
+}
+inline const std::string& Conversation::_internal_pnjid() const {
+  return _impl_.pnjid_.Get();
+}
+inline void Conversation::_internal_set_pnjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.pnjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Conversation::_internal_mutable_pnjid() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.pnjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Conversation::release_pnjid() {
+  // @@protoc_insertion_point(field_release:proto.Conversation.pnJid)
+  if (!_internal_has_pnjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.pnjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pnjid_.IsDefault()) {
+    _impl_.pnjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Conversation::set_allocated_pnjid(std::string* pnjid) {
+  if (pnjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.pnjid_.SetAllocated(pnjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pnjid_.IsDefault()) {
+    _impl_.pnjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pnJid)
+}
+
+// optional bool selfPnExposed = 40;
+inline bool Conversation::_internal_has_selfpnexposed() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Conversation::has_selfpnexposed() const {
+  return _internal_has_selfpnexposed();
+}
+inline void Conversation::clear_selfpnexposed() {
+  _impl_.selfpnexposed_ = false;
+  _impl_._has_bits_[1] &= ~0x00000020u;
+}
+inline bool Conversation::_internal_selfpnexposed() const {
+  return _impl_.selfpnexposed_;
+}
+inline bool Conversation::selfpnexposed() const {
+  // @@protoc_insertion_point(field_get:proto.Conversation.selfPnExposed)
+  return _internal_selfpnexposed();
+}
+inline void Conversation::_internal_set_selfpnexposed(bool value) {
+  _impl_._has_bits_[1] |= 0x00000020u;
+  _impl_.selfpnexposed_ = value;
+}
+inline void Conversation::set_selfpnexposed(bool value) {
+  _internal_set_selfpnexposed(value);
+  // @@protoc_insertion_point(field_set:proto.Conversation.selfPnExposed)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceListMetadata
+
+// optional bytes senderKeyHash = 1;
+inline bool DeviceListMetadata::_internal_has_senderkeyhash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceListMetadata::has_senderkeyhash() const {
+  return _internal_has_senderkeyhash();
+}
+inline void DeviceListMetadata::clear_senderkeyhash() {
+  _impl_.senderkeyhash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceListMetadata::senderkeyhash() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyHash)
+  return _internal_senderkeyhash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceListMetadata::set_senderkeyhash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.senderkeyhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyHash)
+}
+inline std::string* DeviceListMetadata::mutable_senderkeyhash() {
+  std::string* _s = _internal_mutable_senderkeyhash();
+  // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.senderKeyHash)
+  return _s;
+}
+inline const std::string& DeviceListMetadata::_internal_senderkeyhash() const {
+  return _impl_.senderkeyhash_.Get();
+}
+inline void DeviceListMetadata::_internal_set_senderkeyhash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.senderkeyhash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceListMetadata::_internal_mutable_senderkeyhash() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.senderkeyhash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceListMetadata::release_senderkeyhash() {
+  // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.senderKeyHash)
+  if (!_internal_has_senderkeyhash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.senderkeyhash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderkeyhash_.IsDefault()) {
+    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void DeviceListMetadata::set_allocated_senderkeyhash(std::string* senderkeyhash) {
+  if (senderkeyhash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.senderkeyhash_.SetAllocated(senderkeyhash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.senderkeyhash_.IsDefault()) {
+    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.senderKeyHash)
+}
+
+// optional uint64 senderTimestamp = 2;
+inline bool DeviceListMetadata::_internal_has_sendertimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DeviceListMetadata::has_sendertimestamp() const {
+  return _internal_has_sendertimestamp();
+}
+inline void DeviceListMetadata::clear_sendertimestamp() {
+  _impl_.sendertimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint64_t DeviceListMetadata::_internal_sendertimestamp() const {
+  return _impl_.sendertimestamp_;
+}
+inline uint64_t DeviceListMetadata::sendertimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderTimestamp)
+  return _internal_sendertimestamp();
+}
+inline void DeviceListMetadata::_internal_set_sendertimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.sendertimestamp_ = value;
+}
+inline void DeviceListMetadata::set_sendertimestamp(uint64_t value) {
+  _internal_set_sendertimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderTimestamp)
+}
+
+// repeated uint32 senderKeyIndexes = 3 [packed = true];
+inline int DeviceListMetadata::_internal_senderkeyindexes_size() const {
+  return _impl_.senderkeyindexes_.size();
+}
+inline int DeviceListMetadata::senderkeyindexes_size() const {
+  return _internal_senderkeyindexes_size();
+}
+inline void DeviceListMetadata::clear_senderkeyindexes() {
+  _impl_.senderkeyindexes_.Clear();
+}
+inline uint32_t DeviceListMetadata::_internal_senderkeyindexes(int index) const {
+  return _impl_.senderkeyindexes_.Get(index);
+}
+inline uint32_t DeviceListMetadata::senderkeyindexes(int index) const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyIndexes)
+  return _internal_senderkeyindexes(index);
+}
+inline void DeviceListMetadata::set_senderkeyindexes(int index, uint32_t value) {
+  _impl_.senderkeyindexes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyIndexes)
+}
+inline void DeviceListMetadata::_internal_add_senderkeyindexes(uint32_t value) {
+  _impl_.senderkeyindexes_.Add(value);
+}
+inline void DeviceListMetadata::add_senderkeyindexes(uint32_t value) {
+  _internal_add_senderkeyindexes(value);
+  // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.senderKeyIndexes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+DeviceListMetadata::_internal_senderkeyindexes() const {
+  return _impl_.senderkeyindexes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+DeviceListMetadata::senderkeyindexes() const {
+  // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.senderKeyIndexes)
+  return _internal_senderkeyindexes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+DeviceListMetadata::_internal_mutable_senderkeyindexes() {
+  return &_impl_.senderkeyindexes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+DeviceListMetadata::mutable_senderkeyindexes() {
+  // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.senderKeyIndexes)
+  return _internal_mutable_senderkeyindexes();
+}
+
+// optional bytes recipientKeyHash = 8;
+inline bool DeviceListMetadata::_internal_has_recipientkeyhash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceListMetadata::has_recipientkeyhash() const {
+  return _internal_has_recipientkeyhash();
+}
+inline void DeviceListMetadata::clear_recipientkeyhash() {
+  _impl_.recipientkeyhash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& DeviceListMetadata::recipientkeyhash() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyHash)
+  return _internal_recipientkeyhash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceListMetadata::set_recipientkeyhash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.recipientkeyhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyHash)
+}
+inline std::string* DeviceListMetadata::mutable_recipientkeyhash() {
+  std::string* _s = _internal_mutable_recipientkeyhash();
+  // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.recipientKeyHash)
+  return _s;
+}
+inline const std::string& DeviceListMetadata::_internal_recipientkeyhash() const {
+  return _impl_.recipientkeyhash_.Get();
+}
+inline void DeviceListMetadata::_internal_set_recipientkeyhash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.recipientkeyhash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceListMetadata::_internal_mutable_recipientkeyhash() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.recipientkeyhash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceListMetadata::release_recipientkeyhash() {
+  // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.recipientKeyHash)
+  if (!_internal_has_recipientkeyhash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.recipientkeyhash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.recipientkeyhash_.IsDefault()) {
+    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void DeviceListMetadata::set_allocated_recipientkeyhash(std::string* recipientkeyhash) {
+  if (recipientkeyhash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.recipientkeyhash_.SetAllocated(recipientkeyhash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.recipientkeyhash_.IsDefault()) {
+    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.recipientKeyHash)
+}
+
+// optional uint64 recipientTimestamp = 9;
+inline bool DeviceListMetadata::_internal_has_recipienttimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool DeviceListMetadata::has_recipienttimestamp() const {
+  return _internal_has_recipienttimestamp();
+}
+inline void DeviceListMetadata::clear_recipienttimestamp() {
+  _impl_.recipienttimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t DeviceListMetadata::_internal_recipienttimestamp() const {
+  return _impl_.recipienttimestamp_;
+}
+inline uint64_t DeviceListMetadata::recipienttimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientTimestamp)
+  return _internal_recipienttimestamp();
+}
+inline void DeviceListMetadata::_internal_set_recipienttimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.recipienttimestamp_ = value;
+}
+inline void DeviceListMetadata::set_recipienttimestamp(uint64_t value) {
+  _internal_set_recipienttimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientTimestamp)
+}
+
+// repeated uint32 recipientKeyIndexes = 10 [packed = true];
+inline int DeviceListMetadata::_internal_recipientkeyindexes_size() const {
+  return _impl_.recipientkeyindexes_.size();
+}
+inline int DeviceListMetadata::recipientkeyindexes_size() const {
+  return _internal_recipientkeyindexes_size();
+}
+inline void DeviceListMetadata::clear_recipientkeyindexes() {
+  _impl_.recipientkeyindexes_.Clear();
+}
+inline uint32_t DeviceListMetadata::_internal_recipientkeyindexes(int index) const {
+  return _impl_.recipientkeyindexes_.Get(index);
+}
+inline uint32_t DeviceListMetadata::recipientkeyindexes(int index) const {
+  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyIndexes)
+  return _internal_recipientkeyindexes(index);
+}
+inline void DeviceListMetadata::set_recipientkeyindexes(int index, uint32_t value) {
+  _impl_.recipientkeyindexes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyIndexes)
+}
+inline void DeviceListMetadata::_internal_add_recipientkeyindexes(uint32_t value) {
+  _impl_.recipientkeyindexes_.Add(value);
+}
+inline void DeviceListMetadata::add_recipientkeyindexes(uint32_t value) {
+  _internal_add_recipientkeyindexes(value);
+  // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.recipientKeyIndexes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+DeviceListMetadata::_internal_recipientkeyindexes() const {
+  return _impl_.recipientkeyindexes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+DeviceListMetadata::recipientkeyindexes() const {
+  // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.recipientKeyIndexes)
+  return _internal_recipientkeyindexes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+DeviceListMetadata::_internal_mutable_recipientkeyindexes() {
+  return &_impl_.recipientkeyindexes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+DeviceListMetadata::mutable_recipientkeyindexes() {
+  // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.recipientKeyIndexes)
+  return _internal_mutable_recipientkeyindexes();
+}
+
+// -------------------------------------------------------------------
+
+// DeviceProps_AppVersion
+
+// optional uint32 primary = 1;
+inline bool DeviceProps_AppVersion::_internal_has_primary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceProps_AppVersion::has_primary() const {
+  return _internal_has_primary();
+}
+inline void DeviceProps_AppVersion::clear_primary() {
+  _impl_.primary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t DeviceProps_AppVersion::_internal_primary() const {
+  return _impl_.primary_;
+}
+inline uint32_t DeviceProps_AppVersion::primary() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.primary)
+  return _internal_primary();
+}
+inline void DeviceProps_AppVersion::_internal_set_primary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.primary_ = value;
+}
+inline void DeviceProps_AppVersion::set_primary(uint32_t value) {
+  _internal_set_primary(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.primary)
+}
+
+// optional uint32 secondary = 2;
+inline bool DeviceProps_AppVersion::_internal_has_secondary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceProps_AppVersion::has_secondary() const {
+  return _internal_has_secondary();
+}
+inline void DeviceProps_AppVersion::clear_secondary() {
+  _impl_.secondary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t DeviceProps_AppVersion::_internal_secondary() const {
+  return _impl_.secondary_;
+}
+inline uint32_t DeviceProps_AppVersion::secondary() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.secondary)
+  return _internal_secondary();
+}
+inline void DeviceProps_AppVersion::_internal_set_secondary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.secondary_ = value;
+}
+inline void DeviceProps_AppVersion::set_secondary(uint32_t value) {
+  _internal_set_secondary(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.secondary)
+}
+
+// optional uint32 tertiary = 3;
+inline bool DeviceProps_AppVersion::_internal_has_tertiary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DeviceProps_AppVersion::has_tertiary() const {
+  return _internal_has_tertiary();
+}
+inline void DeviceProps_AppVersion::clear_tertiary() {
+  _impl_.tertiary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t DeviceProps_AppVersion::_internal_tertiary() const {
+  return _impl_.tertiary_;
+}
+inline uint32_t DeviceProps_AppVersion::tertiary() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.tertiary)
+  return _internal_tertiary();
+}
+inline void DeviceProps_AppVersion::_internal_set_tertiary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.tertiary_ = value;
+}
+inline void DeviceProps_AppVersion::set_tertiary(uint32_t value) {
+  _internal_set_tertiary(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.tertiary)
+}
+
+// optional uint32 quaternary = 4;
+inline bool DeviceProps_AppVersion::_internal_has_quaternary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool DeviceProps_AppVersion::has_quaternary() const {
+  return _internal_has_quaternary();
+}
+inline void DeviceProps_AppVersion::clear_quaternary() {
+  _impl_.quaternary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t DeviceProps_AppVersion::_internal_quaternary() const {
+  return _impl_.quaternary_;
+}
+inline uint32_t DeviceProps_AppVersion::quaternary() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quaternary)
+  return _internal_quaternary();
+}
+inline void DeviceProps_AppVersion::_internal_set_quaternary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.quaternary_ = value;
+}
+inline void DeviceProps_AppVersion::set_quaternary(uint32_t value) {
+  _internal_set_quaternary(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quaternary)
+}
+
+// optional uint32 quinary = 5;
+inline bool DeviceProps_AppVersion::_internal_has_quinary() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool DeviceProps_AppVersion::has_quinary() const {
+  return _internal_has_quinary();
+}
+inline void DeviceProps_AppVersion::clear_quinary() {
+  _impl_.quinary_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t DeviceProps_AppVersion::_internal_quinary() const {
+  return _impl_.quinary_;
+}
+inline uint32_t DeviceProps_AppVersion::quinary() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quinary)
+  return _internal_quinary();
+}
+inline void DeviceProps_AppVersion::_internal_set_quinary(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.quinary_ = value;
+}
+inline void DeviceProps_AppVersion::set_quinary(uint32_t value) {
+  _internal_set_quinary(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quinary)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceProps
+
+// optional string os = 1;
+inline bool DeviceProps::_internal_has_os() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceProps::has_os() const {
+  return _internal_has_os();
+}
+inline void DeviceProps::clear_os() {
+  _impl_.os_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceProps::os() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.os)
+  return _internal_os();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceProps::set_os(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.os_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.os)
+}
+inline std::string* DeviceProps::mutable_os() {
+  std::string* _s = _internal_mutable_os();
+  // @@protoc_insertion_point(field_mutable:proto.DeviceProps.os)
+  return _s;
+}
+inline const std::string& DeviceProps::_internal_os() const {
+  return _impl_.os_.Get();
+}
+inline void DeviceProps::_internal_set_os(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.os_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceProps::_internal_mutable_os() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.os_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceProps::release_os() {
+  // @@protoc_insertion_point(field_release:proto.DeviceProps.os)
+  if (!_internal_has_os()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.os_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_.IsDefault()) {
+    _impl_.os_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void DeviceProps::set_allocated_os(std::string* os) {
+  if (os != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.os_.SetAllocated(os, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_.IsDefault()) {
+    _impl_.os_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.os)
+}
+
+// optional .proto.DeviceProps.AppVersion version = 2;
+inline bool DeviceProps::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
+  return value;
+}
+inline bool DeviceProps::has_version() const {
+  return _internal_has_version();
+}
+inline void DeviceProps::clear_version() {
+  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::DeviceProps_AppVersion& DeviceProps::_internal_version() const {
+  const ::proto::DeviceProps_AppVersion* p = _impl_.version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::DeviceProps_AppVersion&>(
+      ::proto::_DeviceProps_AppVersion_default_instance_);
+}
+inline const ::proto::DeviceProps_AppVersion& DeviceProps::version() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.version)
+  return _internal_version();
+}
+inline void DeviceProps::unsafe_arena_set_allocated_version(
+    ::proto::DeviceProps_AppVersion* version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
+  }
+  _impl_.version_ = version;
+  if (version) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.DeviceProps.version)
+}
+inline ::proto::DeviceProps_AppVersion* DeviceProps::release_version() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::DeviceProps_AppVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::DeviceProps_AppVersion* DeviceProps::unsafe_arena_release_version() {
+  // @@protoc_insertion_point(field_release:proto.DeviceProps.version)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::DeviceProps_AppVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+  return temp;
+}
+inline ::proto::DeviceProps_AppVersion* DeviceProps::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::DeviceProps_AppVersion>(GetArenaForAllocation());
+    _impl_.version_ = p;
+  }
+  return _impl_.version_;
+}
+inline ::proto::DeviceProps_AppVersion* DeviceProps::mutable_version() {
+  ::proto::DeviceProps_AppVersion* _msg = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:proto.DeviceProps.version)
+  return _msg;
+}
+inline void DeviceProps::set_allocated_version(::proto::DeviceProps_AppVersion* version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.version_;
+  }
+  if (version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
+    if (message_arena != submessage_arena) {
+      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, version, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_ = version;
+  // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.version)
+}
+
+// optional .proto.DeviceProps.PlatformType platformType = 3;
+inline bool DeviceProps::_internal_has_platformtype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DeviceProps::has_platformtype() const {
+  return _internal_has_platformtype();
+}
+inline void DeviceProps::clear_platformtype() {
+  _impl_.platformtype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::DeviceProps_PlatformType DeviceProps::_internal_platformtype() const {
+  return static_cast< ::proto::DeviceProps_PlatformType >(_impl_.platformtype_);
+}
+inline ::proto::DeviceProps_PlatformType DeviceProps::platformtype() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.platformType)
+  return _internal_platformtype();
+}
+inline void DeviceProps::_internal_set_platformtype(::proto::DeviceProps_PlatformType value) {
+  assert(::proto::DeviceProps_PlatformType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.platformtype_ = value;
+}
+inline void DeviceProps::set_platformtype(::proto::DeviceProps_PlatformType value) {
+  _internal_set_platformtype(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.platformType)
+}
+
+// optional bool requireFullSync = 4;
+inline bool DeviceProps::_internal_has_requirefullsync() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool DeviceProps::has_requirefullsync() const {
+  return _internal_has_requirefullsync();
+}
+inline void DeviceProps::clear_requirefullsync() {
+  _impl_.requirefullsync_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool DeviceProps::_internal_requirefullsync() const {
+  return _impl_.requirefullsync_;
+}
+inline bool DeviceProps::requirefullsync() const {
+  // @@protoc_insertion_point(field_get:proto.DeviceProps.requireFullSync)
+  return _internal_requirefullsync();
+}
+inline void DeviceProps::_internal_set_requirefullsync(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.requirefullsync_ = value;
+}
+inline void DeviceProps::set_requirefullsync(bool value) {
+  _internal_set_requirefullsync(value);
+  // @@protoc_insertion_point(field_set:proto.DeviceProps.requireFullSync)
+}
+
+// -------------------------------------------------------------------
+
+// DisappearingMode
+
+// optional .proto.DisappearingMode.Initiator initiator = 1;
+inline bool DisappearingMode::_internal_has_initiator() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DisappearingMode::has_initiator() const {
+  return _internal_has_initiator();
+}
+inline void DisappearingMode::clear_initiator() {
+  _impl_.initiator_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::proto::DisappearingMode_Initiator DisappearingMode::_internal_initiator() const {
+  return static_cast< ::proto::DisappearingMode_Initiator >(_impl_.initiator_);
+}
+inline ::proto::DisappearingMode_Initiator DisappearingMode::initiator() const {
+  // @@protoc_insertion_point(field_get:proto.DisappearingMode.initiator)
+  return _internal_initiator();
+}
+inline void DisappearingMode::_internal_set_initiator(::proto::DisappearingMode_Initiator value) {
+  assert(::proto::DisappearingMode_Initiator_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.initiator_ = value;
+}
+inline void DisappearingMode::set_initiator(::proto::DisappearingMode_Initiator value) {
+  _internal_set_initiator(value);
+  // @@protoc_insertion_point(field_set:proto.DisappearingMode.initiator)
+}
+
+// -------------------------------------------------------------------
+
+// EphemeralSetting
+
+// optional sfixed32 duration = 1;
+inline bool EphemeralSetting::_internal_has_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EphemeralSetting::has_duration() const {
+  return _internal_has_duration();
+}
+inline void EphemeralSetting::clear_duration() {
+  _impl_.duration_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t EphemeralSetting::_internal_duration() const {
+  return _impl_.duration_;
+}
+inline int32_t EphemeralSetting::duration() const {
+  // @@protoc_insertion_point(field_get:proto.EphemeralSetting.duration)
+  return _internal_duration();
+}
+inline void EphemeralSetting::_internal_set_duration(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.duration_ = value;
+}
+inline void EphemeralSetting::set_duration(int32_t value) {
+  _internal_set_duration(value);
+  // @@protoc_insertion_point(field_set:proto.EphemeralSetting.duration)
+}
+
+// optional sfixed64 timestamp = 2;
+inline bool EphemeralSetting::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EphemeralSetting::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void EphemeralSetting::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t EphemeralSetting::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t EphemeralSetting::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.EphemeralSetting.timestamp)
+  return _internal_timestamp();
+}
+inline void EphemeralSetting::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void EphemeralSetting::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.EphemeralSetting.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// ExitCode
+
+// optional uint64 code = 1;
+inline bool ExitCode::_internal_has_code() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExitCode::has_code() const {
+  return _internal_has_code();
+}
+inline void ExitCode::clear_code() {
+  _impl_.code_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t ExitCode::_internal_code() const {
+  return _impl_.code_;
+}
+inline uint64_t ExitCode::code() const {
+  // @@protoc_insertion_point(field_get:proto.ExitCode.code)
+  return _internal_code();
+}
+inline void ExitCode::_internal_set_code(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.code_ = value;
+}
+inline void ExitCode::set_code(uint64_t value) {
+  _internal_set_code(value);
+  // @@protoc_insertion_point(field_set:proto.ExitCode.code)
+}
+
+// optional string text = 2;
+inline bool ExitCode::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ExitCode::has_text() const {
+  return _internal_has_text();
+}
+inline void ExitCode::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ExitCode::text() const {
+  // @@protoc_insertion_point(field_get:proto.ExitCode.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExitCode::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExitCode.text)
+}
+inline std::string* ExitCode::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.ExitCode.text)
+  return _s;
+}
+inline const std::string& ExitCode::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void ExitCode::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExitCode::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExitCode::release_text() {
+  // @@protoc_insertion_point(field_release:proto.ExitCode.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExitCode::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExitCode.text)
+}
+
+// -------------------------------------------------------------------
+
+// ExternalBlobReference
+
+// optional bytes mediaKey = 1;
+inline bool ExternalBlobReference::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void ExternalBlobReference::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ExternalBlobReference::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalBlobReference::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.mediaKey)
+}
+inline std::string* ExternalBlobReference::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.mediaKey)
+  return _s;
+}
+inline const std::string& ExternalBlobReference::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void ExternalBlobReference::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExternalBlobReference::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.mediaKey)
+}
+
+// optional string directPath = 2;
+inline bool ExternalBlobReference::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void ExternalBlobReference::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ExternalBlobReference::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalBlobReference::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.directPath)
+}
+inline std::string* ExternalBlobReference::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.directPath)
+  return _s;
+}
+inline const std::string& ExternalBlobReference::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void ExternalBlobReference::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExternalBlobReference::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.directPath)
+}
+
+// optional string handle = 3;
+inline bool ExternalBlobReference::_internal_has_handle() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_handle() const {
+  return _internal_has_handle();
+}
+inline void ExternalBlobReference::clear_handle() {
+  _impl_.handle_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ExternalBlobReference::handle() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.handle)
+  return _internal_handle();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalBlobReference::set_handle(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.handle)
+}
+inline std::string* ExternalBlobReference::mutable_handle() {
+  std::string* _s = _internal_mutable_handle();
+  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.handle)
+  return _s;
+}
+inline const std::string& ExternalBlobReference::_internal_handle() const {
+  return _impl_.handle_.Get();
+}
+inline void ExternalBlobReference::_internal_set_handle(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.handle_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::_internal_mutable_handle() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.handle_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::release_handle() {
+  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.handle)
+  if (!_internal_has_handle()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.handle_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.handle_.IsDefault()) {
+    _impl_.handle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExternalBlobReference::set_allocated_handle(std::string* handle) {
+  if (handle != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.handle_.SetAllocated(handle, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.handle_.IsDefault()) {
+    _impl_.handle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.handle)
+}
+
+// optional uint64 fileSizeBytes = 4;
+inline bool ExternalBlobReference::_internal_has_filesizebytes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_filesizebytes() const {
+  return _internal_has_filesizebytes();
+}
+inline void ExternalBlobReference::clear_filesizebytes() {
+  _impl_.filesizebytes_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint64_t ExternalBlobReference::_internal_filesizebytes() const {
+  return _impl_.filesizebytes_;
+}
+inline uint64_t ExternalBlobReference::filesizebytes() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSizeBytes)
+  return _internal_filesizebytes();
+}
+inline void ExternalBlobReference::_internal_set_filesizebytes(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.filesizebytes_ = value;
+}
+inline void ExternalBlobReference::set_filesizebytes(uint64_t value) {
+  _internal_set_filesizebytes(value);
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSizeBytes)
+}
+
+// optional bytes fileSha256 = 5;
+inline bool ExternalBlobReference::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void ExternalBlobReference::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ExternalBlobReference::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalBlobReference::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSha256)
+}
+inline std::string* ExternalBlobReference::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileSha256)
+  return _s;
+}
+inline const std::string& ExternalBlobReference::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void ExternalBlobReference::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExternalBlobReference::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileSha256)
+}
+
+// optional bytes fileEncSha256 = 6;
+inline bool ExternalBlobReference::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ExternalBlobReference::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void ExternalBlobReference::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ExternalBlobReference::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalBlobReference::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileEncSha256)
+}
+inline std::string* ExternalBlobReference::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileEncSha256)
+  return _s;
+}
+inline const std::string& ExternalBlobReference::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void ExternalBlobReference::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ExternalBlobReference::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ExternalBlobReference::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileEncSha256)
+}
+
+// -------------------------------------------------------------------
+
+// GlobalSettings
+
+// optional .proto.WallpaperSettings lightThemeWallpaper = 1;
+inline bool GlobalSettings::_internal_has_lightthemewallpaper() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.lightthemewallpaper_ != nullptr);
+  return value;
+}
+inline bool GlobalSettings::has_lightthemewallpaper() const {
+  return _internal_has_lightthemewallpaper();
+}
+inline void GlobalSettings::clear_lightthemewallpaper() {
+  if (_impl_.lightthemewallpaper_ != nullptr) _impl_.lightthemewallpaper_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::WallpaperSettings& GlobalSettings::_internal_lightthemewallpaper() const {
+  const ::proto::WallpaperSettings* p = _impl_.lightthemewallpaper_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
+      ::proto::_WallpaperSettings_default_instance_);
+}
+inline const ::proto::WallpaperSettings& GlobalSettings::lightthemewallpaper() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.lightThemeWallpaper)
+  return _internal_lightthemewallpaper();
+}
+inline void GlobalSettings::unsafe_arena_set_allocated_lightthemewallpaper(
+    ::proto::WallpaperSettings* lightthemewallpaper) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lightthemewallpaper_);
+  }
+  _impl_.lightthemewallpaper_ = lightthemewallpaper;
+  if (lightthemewallpaper) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.lightThemeWallpaper)
+}
+inline ::proto::WallpaperSettings* GlobalSettings::release_lightthemewallpaper() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_;
+  _impl_.lightthemewallpaper_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_lightthemewallpaper() {
+  // @@protoc_insertion_point(field_release:proto.GlobalSettings.lightThemeWallpaper)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_;
+  _impl_.lightthemewallpaper_ = nullptr;
+  return temp;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_lightthemewallpaper() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.lightthemewallpaper_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
+    _impl_.lightthemewallpaper_ = p;
+  }
+  return _impl_.lightthemewallpaper_;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::mutable_lightthemewallpaper() {
+  ::proto::WallpaperSettings* _msg = _internal_mutable_lightthemewallpaper();
+  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.lightThemeWallpaper)
+  return _msg;
+}
+inline void GlobalSettings::set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.lightthemewallpaper_;
+  }
+  if (lightthemewallpaper) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lightthemewallpaper);
+    if (message_arena != submessage_arena) {
+      lightthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, lightthemewallpaper, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.lightthemewallpaper_ = lightthemewallpaper;
+  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.lightThemeWallpaper)
+}
+
+// optional .proto.MediaVisibility mediaVisibility = 2;
+inline bool GlobalSettings::_internal_has_mediavisibility() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool GlobalSettings::has_mediavisibility() const {
+  return _internal_has_mediavisibility();
+}
+inline void GlobalSettings::clear_mediavisibility() {
+  _impl_.mediavisibility_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::proto::MediaVisibility GlobalSettings::_internal_mediavisibility() const {
+  return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_);
+}
+inline ::proto::MediaVisibility GlobalSettings::mediavisibility() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.mediaVisibility)
+  return _internal_mediavisibility();
+}
+inline void GlobalSettings::_internal_set_mediavisibility(::proto::MediaVisibility value) {
+  assert(::proto::MediaVisibility_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.mediavisibility_ = value;
+}
+inline void GlobalSettings::set_mediavisibility(::proto::MediaVisibility value) {
+  _internal_set_mediavisibility(value);
+  // @@protoc_insertion_point(field_set:proto.GlobalSettings.mediaVisibility)
+}
+
+// optional .proto.WallpaperSettings darkThemeWallpaper = 3;
+inline bool GlobalSettings::_internal_has_darkthemewallpaper() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.darkthemewallpaper_ != nullptr);
+  return value;
+}
+inline bool GlobalSettings::has_darkthemewallpaper() const {
+  return _internal_has_darkthemewallpaper();
+}
+inline void GlobalSettings::clear_darkthemewallpaper() {
+  if (_impl_.darkthemewallpaper_ != nullptr) _impl_.darkthemewallpaper_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::WallpaperSettings& GlobalSettings::_internal_darkthemewallpaper() const {
+  const ::proto::WallpaperSettings* p = _impl_.darkthemewallpaper_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
+      ::proto::_WallpaperSettings_default_instance_);
+}
+inline const ::proto::WallpaperSettings& GlobalSettings::darkthemewallpaper() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.darkThemeWallpaper)
+  return _internal_darkthemewallpaper();
+}
+inline void GlobalSettings::unsafe_arena_set_allocated_darkthemewallpaper(
+    ::proto::WallpaperSettings* darkthemewallpaper) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.darkthemewallpaper_);
+  }
+  _impl_.darkthemewallpaper_ = darkthemewallpaper;
+  if (darkthemewallpaper) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.darkThemeWallpaper)
+}
+inline ::proto::WallpaperSettings* GlobalSettings::release_darkthemewallpaper() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_;
+  _impl_.darkthemewallpaper_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_darkthemewallpaper() {
+  // @@protoc_insertion_point(field_release:proto.GlobalSettings.darkThemeWallpaper)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_;
+  _impl_.darkthemewallpaper_ = nullptr;
+  return temp;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_darkthemewallpaper() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.darkthemewallpaper_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
+    _impl_.darkthemewallpaper_ = p;
+  }
+  return _impl_.darkthemewallpaper_;
+}
+inline ::proto::WallpaperSettings* GlobalSettings::mutable_darkthemewallpaper() {
+  ::proto::WallpaperSettings* _msg = _internal_mutable_darkthemewallpaper();
+  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.darkThemeWallpaper)
+  return _msg;
+}
+inline void GlobalSettings::set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.darkthemewallpaper_;
+  }
+  if (darkthemewallpaper) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(darkthemewallpaper);
+    if (message_arena != submessage_arena) {
+      darkthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, darkthemewallpaper, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.darkthemewallpaper_ = darkthemewallpaper;
+  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.darkThemeWallpaper)
+}
+
+// optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
+inline bool GlobalSettings::_internal_has_autodownloadwifi() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.autodownloadwifi_ != nullptr);
+  return value;
+}
+inline bool GlobalSettings::has_autodownloadwifi() const {
+  return _internal_has_autodownloadwifi();
+}
+inline void GlobalSettings::clear_autodownloadwifi() {
+  if (_impl_.autodownloadwifi_ != nullptr) _impl_.autodownloadwifi_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadwifi() const {
+  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadwifi_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
+      ::proto::_AutoDownloadSettings_default_instance_);
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadwifi() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadWiFi)
+  return _internal_autodownloadwifi();
+}
+inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadwifi(
+    ::proto::AutoDownloadSettings* autodownloadwifi) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadwifi_);
+  }
+  _impl_.autodownloadwifi_ = autodownloadwifi;
+  if (autodownloadwifi) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadWiFi)
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadwifi() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_;
+  _impl_.autodownloadwifi_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadwifi() {
+  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadWiFi)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_;
+  _impl_.autodownloadwifi_ = nullptr;
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadwifi() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.autodownloadwifi_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
+    _impl_.autodownloadwifi_ = p;
+  }
+  return _impl_.autodownloadwifi_;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadwifi() {
+  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadwifi();
+  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadWiFi)
+  return _msg;
+}
+inline void GlobalSettings::set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.autodownloadwifi_;
+  }
+  if (autodownloadwifi) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadwifi);
+    if (message_arena != submessage_arena) {
+      autodownloadwifi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, autodownloadwifi, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.autodownloadwifi_ = autodownloadwifi;
+  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadWiFi)
+}
+
+// optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
+inline bool GlobalSettings::_internal_has_autodownloadcellular() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.autodownloadcellular_ != nullptr);
+  return value;
+}
+inline bool GlobalSettings::has_autodownloadcellular() const {
+  return _internal_has_autodownloadcellular();
+}
+inline void GlobalSettings::clear_autodownloadcellular() {
+  if (_impl_.autodownloadcellular_ != nullptr) _impl_.autodownloadcellular_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadcellular() const {
+  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadcellular_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
+      ::proto::_AutoDownloadSettings_default_instance_);
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadcellular() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadCellular)
+  return _internal_autodownloadcellular();
+}
+inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadcellular(
+    ::proto::AutoDownloadSettings* autodownloadcellular) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadcellular_);
+  }
+  _impl_.autodownloadcellular_ = autodownloadcellular;
+  if (autodownloadcellular) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadCellular)
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadcellular() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_;
+  _impl_.autodownloadcellular_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadcellular() {
+  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadCellular)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_;
+  _impl_.autodownloadcellular_ = nullptr;
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadcellular() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.autodownloadcellular_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
+    _impl_.autodownloadcellular_ = p;
+  }
+  return _impl_.autodownloadcellular_;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadcellular() {
+  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadcellular();
+  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadCellular)
+  return _msg;
+}
+inline void GlobalSettings::set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.autodownloadcellular_;
+  }
+  if (autodownloadcellular) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadcellular);
+    if (message_arena != submessage_arena) {
+      autodownloadcellular = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, autodownloadcellular, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.autodownloadcellular_ = autodownloadcellular;
+  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadCellular)
+}
+
+// optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
+inline bool GlobalSettings::_internal_has_autodownloadroaming() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.autodownloadroaming_ != nullptr);
+  return value;
+}
+inline bool GlobalSettings::has_autodownloadroaming() const {
+  return _internal_has_autodownloadroaming();
+}
+inline void GlobalSettings::clear_autodownloadroaming() {
+  if (_impl_.autodownloadroaming_ != nullptr) _impl_.autodownloadroaming_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadroaming() const {
+  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadroaming_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
+      ::proto::_AutoDownloadSettings_default_instance_);
+}
+inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadroaming() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadRoaming)
+  return _internal_autodownloadroaming();
+}
+inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadroaming(
+    ::proto::AutoDownloadSettings* autodownloadroaming) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadroaming_);
+  }
+  _impl_.autodownloadroaming_ = autodownloadroaming;
+  if (autodownloadroaming) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadRoaming)
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadroaming() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_;
+  _impl_.autodownloadroaming_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadroaming() {
+  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadRoaming)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_;
+  _impl_.autodownloadroaming_ = nullptr;
+  return temp;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadroaming() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.autodownloadroaming_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
+    _impl_.autodownloadroaming_ = p;
+  }
+  return _impl_.autodownloadroaming_;
+}
+inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadroaming() {
+  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadroaming();
+  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadRoaming)
+  return _msg;
+}
+inline void GlobalSettings::set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.autodownloadroaming_;
+  }
+  if (autodownloadroaming) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadroaming);
+    if (message_arena != submessage_arena) {
+      autodownloadroaming = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, autodownloadroaming, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.autodownloadroaming_ = autodownloadroaming;
+  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadRoaming)
+}
+
+// optional bool showIndividualNotificationsPreview = 7;
+inline bool GlobalSettings::_internal_has_showindividualnotificationspreview() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool GlobalSettings::has_showindividualnotificationspreview() const {
+  return _internal_has_showindividualnotificationspreview();
+}
+inline void GlobalSettings::clear_showindividualnotificationspreview() {
+  _impl_.showindividualnotificationspreview_ = false;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline bool GlobalSettings::_internal_showindividualnotificationspreview() const {
+  return _impl_.showindividualnotificationspreview_;
+}
+inline bool GlobalSettings::showindividualnotificationspreview() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.showIndividualNotificationsPreview)
+  return _internal_showindividualnotificationspreview();
+}
+inline void GlobalSettings::_internal_set_showindividualnotificationspreview(bool value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.showindividualnotificationspreview_ = value;
+}
+inline void GlobalSettings::set_showindividualnotificationspreview(bool value) {
+  _internal_set_showindividualnotificationspreview(value);
+  // @@protoc_insertion_point(field_set:proto.GlobalSettings.showIndividualNotificationsPreview)
+}
+
+// optional bool showGroupNotificationsPreview = 8;
+inline bool GlobalSettings::_internal_has_showgroupnotificationspreview() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool GlobalSettings::has_showgroupnotificationspreview() const {
+  return _internal_has_showgroupnotificationspreview();
+}
+inline void GlobalSettings::clear_showgroupnotificationspreview() {
+  _impl_.showgroupnotificationspreview_ = false;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline bool GlobalSettings::_internal_showgroupnotificationspreview() const {
+  return _impl_.showgroupnotificationspreview_;
+}
+inline bool GlobalSettings::showgroupnotificationspreview() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.showGroupNotificationsPreview)
+  return _internal_showgroupnotificationspreview();
+}
+inline void GlobalSettings::_internal_set_showgroupnotificationspreview(bool value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.showgroupnotificationspreview_ = value;
+}
+inline void GlobalSettings::set_showgroupnotificationspreview(bool value) {
+  _internal_set_showgroupnotificationspreview(value);
+  // @@protoc_insertion_point(field_set:proto.GlobalSettings.showGroupNotificationsPreview)
+}
+
+// optional int32 disappearingModeDuration = 9;
+inline bool GlobalSettings::_internal_has_disappearingmodeduration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool GlobalSettings::has_disappearingmodeduration() const {
+  return _internal_has_disappearingmodeduration();
+}
+inline void GlobalSettings::clear_disappearingmodeduration() {
+  _impl_.disappearingmodeduration_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline int32_t GlobalSettings::_internal_disappearingmodeduration() const {
+  return _impl_.disappearingmodeduration_;
+}
+inline int32_t GlobalSettings::disappearingmodeduration() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeDuration)
+  return _internal_disappearingmodeduration();
+}
+inline void GlobalSettings::_internal_set_disappearingmodeduration(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.disappearingmodeduration_ = value;
+}
+inline void GlobalSettings::set_disappearingmodeduration(int32_t value) {
+  _internal_set_disappearingmodeduration(value);
+  // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeDuration)
+}
+
+// optional int64 disappearingModeTimestamp = 10;
+inline bool GlobalSettings::_internal_has_disappearingmodetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool GlobalSettings::has_disappearingmodetimestamp() const {
+  return _internal_has_disappearingmodetimestamp();
+}
+inline void GlobalSettings::clear_disappearingmodetimestamp() {
+  _impl_.disappearingmodetimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline int64_t GlobalSettings::_internal_disappearingmodetimestamp() const {
+  return _impl_.disappearingmodetimestamp_;
+}
+inline int64_t GlobalSettings::disappearingmodetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeTimestamp)
+  return _internal_disappearingmodetimestamp();
+}
+inline void GlobalSettings::_internal_set_disappearingmodetimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.disappearingmodetimestamp_ = value;
+}
+inline void GlobalSettings::set_disappearingmodetimestamp(int64_t value) {
+  _internal_set_disappearingmodetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// GroupParticipant
+
+// required string userJid = 1;
+inline bool GroupParticipant::_internal_has_userjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool GroupParticipant::has_userjid() const {
+  return _internal_has_userjid();
+}
+inline void GroupParticipant::clear_userjid() {
+  _impl_.userjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& GroupParticipant::userjid() const {
+  // @@protoc_insertion_point(field_get:proto.GroupParticipant.userJid)
+  return _internal_userjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GroupParticipant::set_userjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.GroupParticipant.userJid)
+}
+inline std::string* GroupParticipant::mutable_userjid() {
+  std::string* _s = _internal_mutable_userjid();
+  // @@protoc_insertion_point(field_mutable:proto.GroupParticipant.userJid)
+  return _s;
+}
+inline const std::string& GroupParticipant::_internal_userjid() const {
+  return _impl_.userjid_.Get();
+}
+inline void GroupParticipant::_internal_set_userjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.userjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GroupParticipant::_internal_mutable_userjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.userjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GroupParticipant::release_userjid() {
+  // @@protoc_insertion_point(field_release:proto.GroupParticipant.userJid)
+  if (!_internal_has_userjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.userjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void GroupParticipant::set_allocated_userjid(std::string* userjid) {
+  if (userjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.GroupParticipant.userJid)
+}
+
+// optional .proto.GroupParticipant.Rank rank = 2;
+inline bool GroupParticipant::_internal_has_rank() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool GroupParticipant::has_rank() const {
+  return _internal_has_rank();
+}
+inline void GroupParticipant::clear_rank() {
+  _impl_.rank_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::GroupParticipant_Rank GroupParticipant::_internal_rank() const {
+  return static_cast< ::proto::GroupParticipant_Rank >(_impl_.rank_);
+}
+inline ::proto::GroupParticipant_Rank GroupParticipant::rank() const {
+  // @@protoc_insertion_point(field_get:proto.GroupParticipant.rank)
+  return _internal_rank();
+}
+inline void GroupParticipant::_internal_set_rank(::proto::GroupParticipant_Rank value) {
+  assert(::proto::GroupParticipant_Rank_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.rank_ = value;
+}
+inline void GroupParticipant::set_rank(::proto::GroupParticipant_Rank value) {
+  _internal_set_rank(value);
+  // @@protoc_insertion_point(field_set:proto.GroupParticipant.rank)
+}
+
+// -------------------------------------------------------------------
+
+// HandshakeMessage_ClientFinish
+
+// optional bytes static = 1;
+inline bool HandshakeMessage_ClientFinish::_internal_has_static_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ClientFinish::has_static_() const {
+  return _internal_has_static_();
+}
+inline void HandshakeMessage_ClientFinish::clear_static_() {
+  _impl_.static__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HandshakeMessage_ClientFinish::static_() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.static)
+  return _internal_static_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ClientFinish::set_static_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.static)
+}
+inline std::string* HandshakeMessage_ClientFinish::mutable_static_() {
+  std::string* _s = _internal_mutable_static_();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.static)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ClientFinish::_internal_static_() const {
+  return _impl_.static__.Get();
+}
+inline void HandshakeMessage_ClientFinish::_internal_set_static_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.static__.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_static_() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.static__.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientFinish::release_static_() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.static)
+  if (!_internal_has_static_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.static__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ClientFinish::set_allocated_static_(std::string* static_) {
+  if (static_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.static)
+}
+
+// optional bytes payload = 2;
+inline bool HandshakeMessage_ClientFinish::_internal_has_payload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ClientFinish::has_payload() const {
+  return _internal_has_payload();
+}
+inline void HandshakeMessage_ClientFinish::clear_payload() {
+  _impl_.payload_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HandshakeMessage_ClientFinish::payload() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.payload)
+  return _internal_payload();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ClientFinish::set_payload(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.payload)
+}
+inline std::string* HandshakeMessage_ClientFinish::mutable_payload() {
+  std::string* _s = _internal_mutable_payload();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.payload)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ClientFinish::_internal_payload() const {
+  return _impl_.payload_.Get();
+}
+inline void HandshakeMessage_ClientFinish::_internal_set_payload(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.payload_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_payload() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.payload_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientFinish::release_payload() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.payload)
+  if (!_internal_has_payload()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.payload_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ClientFinish::set_allocated_payload(std::string* payload) {
+  if (payload != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.payload)
+}
+
+// -------------------------------------------------------------------
+
+// HandshakeMessage_ClientHello
+
+// optional bytes ephemeral = 1;
+inline bool HandshakeMessage_ClientHello::_internal_has_ephemeral() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ClientHello::has_ephemeral() const {
+  return _internal_has_ephemeral();
+}
+inline void HandshakeMessage_ClientHello::clear_ephemeral() {
+  _impl_.ephemeral_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HandshakeMessage_ClientHello::ephemeral() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.ephemeral)
+  return _internal_ephemeral();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ClientHello::set_ephemeral(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.ephemeral_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.ephemeral)
+}
+inline std::string* HandshakeMessage_ClientHello::mutable_ephemeral() {
+  std::string* _s = _internal_mutable_ephemeral();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.ephemeral)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ClientHello::_internal_ephemeral() const {
+  return _impl_.ephemeral_.Get();
+}
+inline void HandshakeMessage_ClientHello::_internal_set_ephemeral(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.ephemeral_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::_internal_mutable_ephemeral() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.ephemeral_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::release_ephemeral() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.ephemeral)
+  if (!_internal_has_ephemeral()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.ephemeral_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeral_.IsDefault()) {
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ClientHello::set_allocated_ephemeral(std::string* ephemeral) {
+  if (ephemeral != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeral_.IsDefault()) {
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.ephemeral)
+}
+
+// optional bytes static = 2;
+inline bool HandshakeMessage_ClientHello::_internal_has_static_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ClientHello::has_static_() const {
+  return _internal_has_static_();
+}
+inline void HandshakeMessage_ClientHello::clear_static_() {
+  _impl_.static__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HandshakeMessage_ClientHello::static_() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.static)
+  return _internal_static_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ClientHello::set_static_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.static)
+}
+inline std::string* HandshakeMessage_ClientHello::mutable_static_() {
+  std::string* _s = _internal_mutable_static_();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.static)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ClientHello::_internal_static_() const {
+  return _impl_.static__.Get();
+}
+inline void HandshakeMessage_ClientHello::_internal_set_static_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.static__.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::_internal_mutable_static_() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.static__.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::release_static_() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.static)
+  if (!_internal_has_static_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.static__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ClientHello::set_allocated_static_(std::string* static_) {
+  if (static_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.static)
+}
+
+// optional bytes payload = 3;
+inline bool HandshakeMessage_ClientHello::_internal_has_payload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ClientHello::has_payload() const {
+  return _internal_has_payload();
+}
+inline void HandshakeMessage_ClientHello::clear_payload() {
+  _impl_.payload_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& HandshakeMessage_ClientHello::payload() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.payload)
+  return _internal_payload();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ClientHello::set_payload(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.payload)
+}
+inline std::string* HandshakeMessage_ClientHello::mutable_payload() {
+  std::string* _s = _internal_mutable_payload();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.payload)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ClientHello::_internal_payload() const {
+  return _impl_.payload_.Get();
+}
+inline void HandshakeMessage_ClientHello::_internal_set_payload(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.payload_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::_internal_mutable_payload() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.payload_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ClientHello::release_payload() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.payload)
+  if (!_internal_has_payload()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.payload_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ClientHello::set_allocated_payload(std::string* payload) {
+  if (payload != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.payload)
+}
+
+// -------------------------------------------------------------------
+
+// HandshakeMessage_ServerHello
+
+// optional bytes ephemeral = 1;
+inline bool HandshakeMessage_ServerHello::_internal_has_ephemeral() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ServerHello::has_ephemeral() const {
+  return _internal_has_ephemeral();
+}
+inline void HandshakeMessage_ServerHello::clear_ephemeral() {
+  _impl_.ephemeral_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HandshakeMessage_ServerHello::ephemeral() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.ephemeral)
+  return _internal_ephemeral();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ServerHello::set_ephemeral(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.ephemeral_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.ephemeral)
+}
+inline std::string* HandshakeMessage_ServerHello::mutable_ephemeral() {
+  std::string* _s = _internal_mutable_ephemeral();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.ephemeral)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ServerHello::_internal_ephemeral() const {
+  return _impl_.ephemeral_.Get();
+}
+inline void HandshakeMessage_ServerHello::_internal_set_ephemeral(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.ephemeral_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::_internal_mutable_ephemeral() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.ephemeral_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::release_ephemeral() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.ephemeral)
+  if (!_internal_has_ephemeral()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.ephemeral_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeral_.IsDefault()) {
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ServerHello::set_allocated_ephemeral(std::string* ephemeral) {
+  if (ephemeral != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ephemeral_.IsDefault()) {
+    _impl_.ephemeral_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.ephemeral)
+}
+
+// optional bytes static = 2;
+inline bool HandshakeMessage_ServerHello::_internal_has_static_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ServerHello::has_static_() const {
+  return _internal_has_static_();
+}
+inline void HandshakeMessage_ServerHello::clear_static_() {
+  _impl_.static__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HandshakeMessage_ServerHello::static_() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.static)
+  return _internal_static_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ServerHello::set_static_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.static)
+}
+inline std::string* HandshakeMessage_ServerHello::mutable_static_() {
+  std::string* _s = _internal_mutable_static_();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.static)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ServerHello::_internal_static_() const {
+  return _impl_.static__.Get();
+}
+inline void HandshakeMessage_ServerHello::_internal_set_static_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.static__.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::_internal_mutable_static_() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.static__.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::release_static_() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.static)
+  if (!_internal_has_static_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.static__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ServerHello::set_allocated_static_(std::string* static_) {
+  if (static_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.static__.IsDefault()) {
+    _impl_.static__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.static)
+}
+
+// optional bytes payload = 3;
+inline bool HandshakeMessage_ServerHello::_internal_has_payload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool HandshakeMessage_ServerHello::has_payload() const {
+  return _internal_has_payload();
+}
+inline void HandshakeMessage_ServerHello::clear_payload() {
+  _impl_.payload_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& HandshakeMessage_ServerHello::payload() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.payload)
+  return _internal_payload();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeMessage_ServerHello::set_payload(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.payload)
+}
+inline std::string* HandshakeMessage_ServerHello::mutable_payload() {
+  std::string* _s = _internal_mutable_payload();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.payload)
+  return _s;
+}
+inline const std::string& HandshakeMessage_ServerHello::_internal_payload() const {
+  return _impl_.payload_.Get();
+}
+inline void HandshakeMessage_ServerHello::_internal_set_payload(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.payload_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::_internal_mutable_payload() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.payload_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HandshakeMessage_ServerHello::release_payload() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.payload)
+  if (!_internal_has_payload()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.payload_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HandshakeMessage_ServerHello::set_allocated_payload(std::string* payload) {
+  if (payload != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.payload_.IsDefault()) {
+    _impl_.payload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.payload)
+}
+
+// -------------------------------------------------------------------
+
+// HandshakeMessage
+
+// optional .proto.HandshakeMessage.ClientHello clientHello = 2;
+inline bool HandshakeMessage::_internal_has_clienthello() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.clienthello_ != nullptr);
+  return value;
+}
+inline bool HandshakeMessage::has_clienthello() const {
+  return _internal_has_clienthello();
+}
+inline void HandshakeMessage::clear_clienthello() {
+  if (_impl_.clienthello_ != nullptr) _impl_.clienthello_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::_internal_clienthello() const {
+  const ::proto::HandshakeMessage_ClientHello* p = _impl_.clienthello_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ClientHello&>(
+      ::proto::_HandshakeMessage_ClientHello_default_instance_);
+}
+inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::clienthello() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientHello)
+  return _internal_clienthello();
+}
+inline void HandshakeMessage::unsafe_arena_set_allocated_clienthello(
+    ::proto::HandshakeMessage_ClientHello* clienthello) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clienthello_);
+  }
+  _impl_.clienthello_ = clienthello;
+  if (clienthello) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientHello)
+}
+inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::release_clienthello() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_;
+  _impl_.clienthello_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::unsafe_arena_release_clienthello() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientHello)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_;
+  _impl_.clienthello_ = nullptr;
+  return temp;
+}
+inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::_internal_mutable_clienthello() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.clienthello_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(GetArenaForAllocation());
+    _impl_.clienthello_ = p;
+  }
+  return _impl_.clienthello_;
+}
+inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::mutable_clienthello() {
+  ::proto::HandshakeMessage_ClientHello* _msg = _internal_mutable_clienthello();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientHello)
+  return _msg;
+}
+inline void HandshakeMessage::set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.clienthello_;
+  }
+  if (clienthello) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clienthello);
+    if (message_arena != submessage_arena) {
+      clienthello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, clienthello, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.clienthello_ = clienthello;
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientHello)
+}
+
+// optional .proto.HandshakeMessage.ServerHello serverHello = 3;
+inline bool HandshakeMessage::_internal_has_serverhello() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.serverhello_ != nullptr);
+  return value;
+}
+inline bool HandshakeMessage::has_serverhello() const {
+  return _internal_has_serverhello();
+}
+inline void HandshakeMessage::clear_serverhello() {
+  if (_impl_.serverhello_ != nullptr) _impl_.serverhello_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::_internal_serverhello() const {
+  const ::proto::HandshakeMessage_ServerHello* p = _impl_.serverhello_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ServerHello&>(
+      ::proto::_HandshakeMessage_ServerHello_default_instance_);
+}
+inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::serverhello() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.serverHello)
+  return _internal_serverhello();
+}
+inline void HandshakeMessage::unsafe_arena_set_allocated_serverhello(
+    ::proto::HandshakeMessage_ServerHello* serverhello) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serverhello_);
+  }
+  _impl_.serverhello_ = serverhello;
+  if (serverhello) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.serverHello)
+}
+inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::release_serverhello() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_;
+  _impl_.serverhello_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::unsafe_arena_release_serverhello() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.serverHello)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_;
+  _impl_.serverhello_ = nullptr;
+  return temp;
+}
+inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::_internal_mutable_serverhello() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.serverhello_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(GetArenaForAllocation());
+    _impl_.serverhello_ = p;
+  }
+  return _impl_.serverhello_;
+}
+inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::mutable_serverhello() {
+  ::proto::HandshakeMessage_ServerHello* _msg = _internal_mutable_serverhello();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.serverHello)
+  return _msg;
+}
+inline void HandshakeMessage::set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.serverhello_;
+  }
+  if (serverhello) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(serverhello);
+    if (message_arena != submessage_arena) {
+      serverhello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, serverhello, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.serverhello_ = serverhello;
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.serverHello)
+}
+
+// optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
+inline bool HandshakeMessage::_internal_has_clientfinish() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.clientfinish_ != nullptr);
+  return value;
+}
+inline bool HandshakeMessage::has_clientfinish() const {
+  return _internal_has_clientfinish();
+}
+inline void HandshakeMessage::clear_clientfinish() {
+  if (_impl_.clientfinish_ != nullptr) _impl_.clientfinish_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::_internal_clientfinish() const {
+  const ::proto::HandshakeMessage_ClientFinish* p = _impl_.clientfinish_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ClientFinish&>(
+      ::proto::_HandshakeMessage_ClientFinish_default_instance_);
+}
+inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::clientfinish() const {
+  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientFinish)
+  return _internal_clientfinish();
+}
+inline void HandshakeMessage::unsafe_arena_set_allocated_clientfinish(
+    ::proto::HandshakeMessage_ClientFinish* clientfinish) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clientfinish_);
+  }
+  _impl_.clientfinish_ = clientfinish;
+  if (clientfinish) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientFinish)
+}
+inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::release_clientfinish() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_;
+  _impl_.clientfinish_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::unsafe_arena_release_clientfinish() {
+  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientFinish)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_;
+  _impl_.clientfinish_ = nullptr;
+  return temp;
+}
+inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::_internal_mutable_clientfinish() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.clientfinish_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(GetArenaForAllocation());
+    _impl_.clientfinish_ = p;
+  }
+  return _impl_.clientfinish_;
+}
+inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::mutable_clientfinish() {
+  ::proto::HandshakeMessage_ClientFinish* _msg = _internal_mutable_clientfinish();
+  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientFinish)
+  return _msg;
+}
+inline void HandshakeMessage::set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.clientfinish_;
+  }
+  if (clientfinish) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clientfinish);
+    if (message_arena != submessage_arena) {
+      clientfinish = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, clientfinish, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.clientfinish_ = clientfinish;
+  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientFinish)
+}
+
+// -------------------------------------------------------------------
+
+// HistorySync
+
+// required .proto.HistorySync.HistorySyncType syncType = 1;
+inline bool HistorySync::_internal_has_synctype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool HistorySync::has_synctype() const {
+  return _internal_has_synctype();
+}
+inline void HistorySync::clear_synctype() {
+  _impl_.synctype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::HistorySync_HistorySyncType HistorySync::_internal_synctype() const {
+  return static_cast< ::proto::HistorySync_HistorySyncType >(_impl_.synctype_);
+}
+inline ::proto::HistorySync_HistorySyncType HistorySync::synctype() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.syncType)
+  return _internal_synctype();
+}
+inline void HistorySync::_internal_set_synctype(::proto::HistorySync_HistorySyncType value) {
+  assert(::proto::HistorySync_HistorySyncType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.synctype_ = value;
+}
+inline void HistorySync::set_synctype(::proto::HistorySync_HistorySyncType value) {
+  _internal_set_synctype(value);
+  // @@protoc_insertion_point(field_set:proto.HistorySync.syncType)
+}
+
+// repeated .proto.Conversation conversations = 2;
+inline int HistorySync::_internal_conversations_size() const {
+  return _impl_.conversations_.size();
+}
+inline int HistorySync::conversations_size() const {
+  return _internal_conversations_size();
+}
+inline void HistorySync::clear_conversations() {
+  _impl_.conversations_.Clear();
+}
+inline ::proto::Conversation* HistorySync::mutable_conversations(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.conversations)
+  return _impl_.conversations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >*
+HistorySync::mutable_conversations() {
+  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.conversations)
+  return &_impl_.conversations_;
+}
+inline const ::proto::Conversation& HistorySync::_internal_conversations(int index) const {
+  return _impl_.conversations_.Get(index);
+}
+inline const ::proto::Conversation& HistorySync::conversations(int index) const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.conversations)
+  return _internal_conversations(index);
+}
+inline ::proto::Conversation* HistorySync::_internal_add_conversations() {
+  return _impl_.conversations_.Add();
+}
+inline ::proto::Conversation* HistorySync::add_conversations() {
+  ::proto::Conversation* _add = _internal_add_conversations();
+  // @@protoc_insertion_point(field_add:proto.HistorySync.conversations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >&
+HistorySync::conversations() const {
+  // @@protoc_insertion_point(field_list:proto.HistorySync.conversations)
+  return _impl_.conversations_;
+}
+
+// repeated .proto.WebMessageInfo statusV3Messages = 3;
+inline int HistorySync::_internal_statusv3messages_size() const {
+  return _impl_.statusv3messages_.size();
+}
+inline int HistorySync::statusv3messages_size() const {
+  return _internal_statusv3messages_size();
+}
+inline void HistorySync::clear_statusv3messages() {
+  _impl_.statusv3messages_.Clear();
+}
+inline ::proto::WebMessageInfo* HistorySync::mutable_statusv3messages(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.statusV3Messages)
+  return _impl_.statusv3messages_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
+HistorySync::mutable_statusv3messages() {
+  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.statusV3Messages)
+  return &_impl_.statusv3messages_;
+}
+inline const ::proto::WebMessageInfo& HistorySync::_internal_statusv3messages(int index) const {
+  return _impl_.statusv3messages_.Get(index);
+}
+inline const ::proto::WebMessageInfo& HistorySync::statusv3messages(int index) const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.statusV3Messages)
+  return _internal_statusv3messages(index);
+}
+inline ::proto::WebMessageInfo* HistorySync::_internal_add_statusv3messages() {
+  return _impl_.statusv3messages_.Add();
+}
+inline ::proto::WebMessageInfo* HistorySync::add_statusv3messages() {
+  ::proto::WebMessageInfo* _add = _internal_add_statusv3messages();
+  // @@protoc_insertion_point(field_add:proto.HistorySync.statusV3Messages)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
+HistorySync::statusv3messages() const {
+  // @@protoc_insertion_point(field_list:proto.HistorySync.statusV3Messages)
+  return _impl_.statusv3messages_;
+}
+
+// optional uint32 chunkOrder = 5;
+inline bool HistorySync::_internal_has_chunkorder() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool HistorySync::has_chunkorder() const {
+  return _internal_has_chunkorder();
+}
+inline void HistorySync::clear_chunkorder() {
+  _impl_.chunkorder_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t HistorySync::_internal_chunkorder() const {
+  return _impl_.chunkorder_;
+}
+inline uint32_t HistorySync::chunkorder() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.chunkOrder)
+  return _internal_chunkorder();
+}
+inline void HistorySync::_internal_set_chunkorder(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.chunkorder_ = value;
+}
+inline void HistorySync::set_chunkorder(uint32_t value) {
+  _internal_set_chunkorder(value);
+  // @@protoc_insertion_point(field_set:proto.HistorySync.chunkOrder)
+}
+
+// optional uint32 progress = 6;
+inline bool HistorySync::_internal_has_progress() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool HistorySync::has_progress() const {
+  return _internal_has_progress();
+}
+inline void HistorySync::clear_progress() {
+  _impl_.progress_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t HistorySync::_internal_progress() const {
+  return _impl_.progress_;
+}
+inline uint32_t HistorySync::progress() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.progress)
+  return _internal_progress();
+}
+inline void HistorySync::_internal_set_progress(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.progress_ = value;
+}
+inline void HistorySync::set_progress(uint32_t value) {
+  _internal_set_progress(value);
+  // @@protoc_insertion_point(field_set:proto.HistorySync.progress)
+}
+
+// repeated .proto.Pushname pushnames = 7;
+inline int HistorySync::_internal_pushnames_size() const {
+  return _impl_.pushnames_.size();
+}
+inline int HistorySync::pushnames_size() const {
+  return _internal_pushnames_size();
+}
+inline void HistorySync::clear_pushnames() {
+  _impl_.pushnames_.Clear();
+}
+inline ::proto::Pushname* HistorySync::mutable_pushnames(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.pushnames)
+  return _impl_.pushnames_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >*
+HistorySync::mutable_pushnames() {
+  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pushnames)
+  return &_impl_.pushnames_;
+}
+inline const ::proto::Pushname& HistorySync::_internal_pushnames(int index) const {
+  return _impl_.pushnames_.Get(index);
+}
+inline const ::proto::Pushname& HistorySync::pushnames(int index) const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.pushnames)
+  return _internal_pushnames(index);
+}
+inline ::proto::Pushname* HistorySync::_internal_add_pushnames() {
+  return _impl_.pushnames_.Add();
+}
+inline ::proto::Pushname* HistorySync::add_pushnames() {
+  ::proto::Pushname* _add = _internal_add_pushnames();
+  // @@protoc_insertion_point(field_add:proto.HistorySync.pushnames)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >&
+HistorySync::pushnames() const {
+  // @@protoc_insertion_point(field_list:proto.HistorySync.pushnames)
+  return _impl_.pushnames_;
+}
+
+// optional .proto.GlobalSettings globalSettings = 8;
+inline bool HistorySync::_internal_has_globalsettings() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.globalsettings_ != nullptr);
+  return value;
+}
+inline bool HistorySync::has_globalsettings() const {
+  return _internal_has_globalsettings();
+}
+inline void HistorySync::clear_globalsettings() {
+  if (_impl_.globalsettings_ != nullptr) _impl_.globalsettings_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::GlobalSettings& HistorySync::_internal_globalsettings() const {
+  const ::proto::GlobalSettings* p = _impl_.globalsettings_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::GlobalSettings&>(
+      ::proto::_GlobalSettings_default_instance_);
+}
+inline const ::proto::GlobalSettings& HistorySync::globalsettings() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.globalSettings)
+  return _internal_globalsettings();
+}
+inline void HistorySync::unsafe_arena_set_allocated_globalsettings(
+    ::proto::GlobalSettings* globalsettings) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.globalsettings_);
+  }
+  _impl_.globalsettings_ = globalsettings;
+  if (globalsettings) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySync.globalSettings)
+}
+inline ::proto::GlobalSettings* HistorySync::release_globalsettings() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::GlobalSettings* temp = _impl_.globalsettings_;
+  _impl_.globalsettings_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::GlobalSettings* HistorySync::unsafe_arena_release_globalsettings() {
+  // @@protoc_insertion_point(field_release:proto.HistorySync.globalSettings)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::GlobalSettings* temp = _impl_.globalsettings_;
+  _impl_.globalsettings_ = nullptr;
+  return temp;
+}
+inline ::proto::GlobalSettings* HistorySync::_internal_mutable_globalsettings() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.globalsettings_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::GlobalSettings>(GetArenaForAllocation());
+    _impl_.globalsettings_ = p;
+  }
+  return _impl_.globalsettings_;
+}
+inline ::proto::GlobalSettings* HistorySync::mutable_globalsettings() {
+  ::proto::GlobalSettings* _msg = _internal_mutable_globalsettings();
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.globalSettings)
+  return _msg;
+}
+inline void HistorySync::set_allocated_globalsettings(::proto::GlobalSettings* globalsettings) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.globalsettings_;
+  }
+  if (globalsettings) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(globalsettings);
+    if (message_arena != submessage_arena) {
+      globalsettings = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, globalsettings, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.globalsettings_ = globalsettings;
+  // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.globalSettings)
+}
+
+// optional bytes threadIdUserSecret = 9;
+inline bool HistorySync::_internal_has_threadidusersecret() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HistorySync::has_threadidusersecret() const {
+  return _internal_has_threadidusersecret();
+}
+inline void HistorySync::clear_threadidusersecret() {
+  _impl_.threadidusersecret_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HistorySync::threadidusersecret() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.threadIdUserSecret)
+  return _internal_threadidusersecret();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HistorySync::set_threadidusersecret(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.threadidusersecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HistorySync.threadIdUserSecret)
+}
+inline std::string* HistorySync::mutable_threadidusersecret() {
+  std::string* _s = _internal_mutable_threadidusersecret();
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.threadIdUserSecret)
+  return _s;
+}
+inline const std::string& HistorySync::_internal_threadidusersecret() const {
+  return _impl_.threadidusersecret_.Get();
+}
+inline void HistorySync::_internal_set_threadidusersecret(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.threadidusersecret_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HistorySync::_internal_mutable_threadidusersecret() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.threadidusersecret_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HistorySync::release_threadidusersecret() {
+  // @@protoc_insertion_point(field_release:proto.HistorySync.threadIdUserSecret)
+  if (!_internal_has_threadidusersecret()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.threadidusersecret_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.threadidusersecret_.IsDefault()) {
+    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HistorySync::set_allocated_threadidusersecret(std::string* threadidusersecret) {
+  if (threadidusersecret != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.threadidusersecret_.SetAllocated(threadidusersecret, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.threadidusersecret_.IsDefault()) {
+    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.threadIdUserSecret)
+}
+
+// optional uint32 threadDsTimeframeOffset = 10;
+inline bool HistorySync::_internal_has_threaddstimeframeoffset() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool HistorySync::has_threaddstimeframeoffset() const {
+  return _internal_has_threaddstimeframeoffset();
+}
+inline void HistorySync::clear_threaddstimeframeoffset() {
+  _impl_.threaddstimeframeoffset_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint32_t HistorySync::_internal_threaddstimeframeoffset() const {
+  return _impl_.threaddstimeframeoffset_;
+}
+inline uint32_t HistorySync::threaddstimeframeoffset() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.threadDsTimeframeOffset)
+  return _internal_threaddstimeframeoffset();
+}
+inline void HistorySync::_internal_set_threaddstimeframeoffset(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.threaddstimeframeoffset_ = value;
+}
+inline void HistorySync::set_threaddstimeframeoffset(uint32_t value) {
+  _internal_set_threaddstimeframeoffset(value);
+  // @@protoc_insertion_point(field_set:proto.HistorySync.threadDsTimeframeOffset)
+}
+
+// repeated .proto.StickerMetadata recentStickers = 11;
+inline int HistorySync::_internal_recentstickers_size() const {
+  return _impl_.recentstickers_.size();
+}
+inline int HistorySync::recentstickers_size() const {
+  return _internal_recentstickers_size();
+}
+inline void HistorySync::clear_recentstickers() {
+  _impl_.recentstickers_.Clear();
+}
+inline ::proto::StickerMetadata* HistorySync::mutable_recentstickers(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.recentStickers)
+  return _impl_.recentstickers_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >*
+HistorySync::mutable_recentstickers() {
+  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.recentStickers)
+  return &_impl_.recentstickers_;
+}
+inline const ::proto::StickerMetadata& HistorySync::_internal_recentstickers(int index) const {
+  return _impl_.recentstickers_.Get(index);
+}
+inline const ::proto::StickerMetadata& HistorySync::recentstickers(int index) const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.recentStickers)
+  return _internal_recentstickers(index);
+}
+inline ::proto::StickerMetadata* HistorySync::_internal_add_recentstickers() {
+  return _impl_.recentstickers_.Add();
+}
+inline ::proto::StickerMetadata* HistorySync::add_recentstickers() {
+  ::proto::StickerMetadata* _add = _internal_add_recentstickers();
+  // @@protoc_insertion_point(field_add:proto.HistorySync.recentStickers)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >&
+HistorySync::recentstickers() const {
+  // @@protoc_insertion_point(field_list:proto.HistorySync.recentStickers)
+  return _impl_.recentstickers_;
+}
+
+// repeated .proto.PastParticipants pastParticipants = 12;
+inline int HistorySync::_internal_pastparticipants_size() const {
+  return _impl_.pastparticipants_.size();
+}
+inline int HistorySync::pastparticipants_size() const {
+  return _internal_pastparticipants_size();
+}
+inline void HistorySync::clear_pastparticipants() {
+  _impl_.pastparticipants_.Clear();
+}
+inline ::proto::PastParticipants* HistorySync::mutable_pastparticipants(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.HistorySync.pastParticipants)
+  return _impl_.pastparticipants_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >*
+HistorySync::mutable_pastparticipants() {
+  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pastParticipants)
+  return &_impl_.pastparticipants_;
+}
+inline const ::proto::PastParticipants& HistorySync::_internal_pastparticipants(int index) const {
+  return _impl_.pastparticipants_.Get(index);
+}
+inline const ::proto::PastParticipants& HistorySync::pastparticipants(int index) const {
+  // @@protoc_insertion_point(field_get:proto.HistorySync.pastParticipants)
+  return _internal_pastparticipants(index);
+}
+inline ::proto::PastParticipants* HistorySync::_internal_add_pastparticipants() {
+  return _impl_.pastparticipants_.Add();
+}
+inline ::proto::PastParticipants* HistorySync::add_pastparticipants() {
+  ::proto::PastParticipants* _add = _internal_add_pastparticipants();
+  // @@protoc_insertion_point(field_add:proto.HistorySync.pastParticipants)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >&
+HistorySync::pastparticipants() const {
+  // @@protoc_insertion_point(field_list:proto.HistorySync.pastParticipants)
+  return _impl_.pastparticipants_;
+}
+
+// -------------------------------------------------------------------
+
+// HistorySyncMsg
+
+// optional .proto.WebMessageInfo message = 1;
+inline bool HistorySyncMsg::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
+  return value;
+}
+inline bool HistorySyncMsg::has_message() const {
+  return _internal_has_message();
+}
+inline void HistorySyncMsg::clear_message() {
+  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::WebMessageInfo& HistorySyncMsg::_internal_message() const {
+  const ::proto::WebMessageInfo* p = _impl_.message_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::WebMessageInfo&>(
+      ::proto::_WebMessageInfo_default_instance_);
+}
+inline const ::proto::WebMessageInfo& HistorySyncMsg::message() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.message)
+  return _internal_message();
+}
+inline void HistorySyncMsg::unsafe_arena_set_allocated_message(
+    ::proto::WebMessageInfo* message) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
+  }
+  _impl_.message_ = message;
+  if (message) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySyncMsg.message)
+}
+inline ::proto::WebMessageInfo* HistorySyncMsg::release_message() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::WebMessageInfo* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::WebMessageInfo* HistorySyncMsg::unsafe_arena_release_message() {
+  // @@protoc_insertion_point(field_release:proto.HistorySyncMsg.message)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::WebMessageInfo* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+  return temp;
+}
+inline ::proto::WebMessageInfo* HistorySyncMsg::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.message_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::WebMessageInfo>(GetArenaForAllocation());
+    _impl_.message_ = p;
+  }
+  return _impl_.message_;
+}
+inline ::proto::WebMessageInfo* HistorySyncMsg::mutable_message() {
+  ::proto::WebMessageInfo* _msg = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.HistorySyncMsg.message)
+  return _msg;
+}
+inline void HistorySyncMsg::set_allocated_message(::proto::WebMessageInfo* message) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.message_;
+  }
+  if (message) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
+    if (message_arena != submessage_arena) {
+      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, message, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.message_ = message;
+  // @@protoc_insertion_point(field_set_allocated:proto.HistorySyncMsg.message)
+}
+
+// optional uint64 msgOrderId = 2;
+inline bool HistorySyncMsg::_internal_has_msgorderid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HistorySyncMsg::has_msgorderid() const {
+  return _internal_has_msgorderid();
+}
+inline void HistorySyncMsg::clear_msgorderid() {
+  _impl_.msgorderid_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t HistorySyncMsg::_internal_msgorderid() const {
+  return _impl_.msgorderid_;
+}
+inline uint64_t HistorySyncMsg::msgorderid() const {
+  // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.msgOrderId)
+  return _internal_msgorderid();
+}
+inline void HistorySyncMsg::_internal_set_msgorderid(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.msgorderid_ = value;
+}
+inline void HistorySyncMsg::set_msgorderid(uint64_t value) {
+  _internal_set_msgorderid(value);
+  // @@protoc_insertion_point(field_set:proto.HistorySyncMsg.msgOrderId)
+}
+
+// -------------------------------------------------------------------
+
+// HydratedTemplateButton_HydratedCallButton
+
+// optional string displayText = 1;
+inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedCallButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void HydratedTemplateButton_HydratedCallButton::clear_displaytext() {
+  _impl_.displaytext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HydratedTemplateButton_HydratedCallButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.displayText)
+  return _internal_displaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedCallButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.displayText)
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_displaytext() {
+  std::string* _s = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.displayText)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_displaytext() const {
+  return _impl_.displaytext_.Get();
+}
+inline void HydratedTemplateButton_HydratedCallButton::_internal_set_displaytext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.displayText)
+  if (!_internal_has_displaytext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displaytext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedCallButton::set_allocated_displaytext(std::string* displaytext) {
+  if (displaytext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.displayText)
+}
+
+// optional string phoneNumber = 2;
+inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_phonenumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedCallButton::has_phonenumber() const {
+  return _internal_has_phonenumber();
+}
+inline void HydratedTemplateButton_HydratedCallButton::clear_phonenumber() {
+  _impl_.phonenumber_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HydratedTemplateButton_HydratedCallButton::phonenumber() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
+  return _internal_phonenumber();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedCallButton::set_phonenumber(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.phonenumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_phonenumber() {
+  std::string* _s = _internal_mutable_phonenumber();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_phonenumber() const {
+  return _impl_.phonenumber_.Get();
+}
+inline void HydratedTemplateButton_HydratedCallButton::_internal_set_phonenumber(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.phonenumber_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_phonenumber() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.phonenumber_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedCallButton::release_phonenumber() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
+  if (!_internal_has_phonenumber()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.phonenumber_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phonenumber_.IsDefault()) {
+    _impl_.phonenumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedCallButton::set_allocated_phonenumber(std::string* phonenumber) {
+  if (phonenumber != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.phonenumber_.SetAllocated(phonenumber, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phonenumber_.IsDefault()) {
+    _impl_.phonenumber_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
+}
+
+// -------------------------------------------------------------------
+
+// HydratedTemplateButton_HydratedQuickReplyButton
+
+// optional string displayText = 1;
+inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_displaytext() {
+  _impl_.displaytext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
+  return _internal_displaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedQuickReplyButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_displaytext() {
+  std::string* _s = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_displaytext() const {
+  return _impl_.displaytext_.Get();
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_displaytext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
+  if (!_internal_has_displaytext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displaytext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_displaytext(std::string* displaytext) {
+  if (displaytext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
+}
+
+// optional string id = 2;
+inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_id() const {
+  return _internal_has_id();
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::id() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedQuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_id() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
+}
+
+// -------------------------------------------------------------------
+
+// HydratedTemplateButton_HydratedURLButton
+
+// optional string displayText = 1;
+inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedURLButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void HydratedTemplateButton_HydratedURLButton::clear_displaytext() {
+  _impl_.displaytext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HydratedTemplateButton_HydratedURLButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.displayText)
+  return _internal_displaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedURLButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.displayText)
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_displaytext() {
+  std::string* _s = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.displayText)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_displaytext() const {
+  return _impl_.displaytext_.Get();
+}
+inline void HydratedTemplateButton_HydratedURLButton::_internal_set_displaytext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.displayText)
+  if (!_internal_has_displaytext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displaytext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedURLButton::set_allocated_displaytext(std::string* displaytext) {
+  if (displaytext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.displayText)
+}
+
+// optional string url = 2;
+inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton_HydratedURLButton::has_url() const {
+  return _internal_has_url();
+}
+inline void HydratedTemplateButton_HydratedURLButton::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HydratedTemplateButton_HydratedURLButton::url() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HydratedTemplateButton_HydratedURLButton::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.url)
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.url)
+  return _s;
+}
+inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void HydratedTemplateButton_HydratedURLButton::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HydratedTemplateButton_HydratedURLButton::release_url() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HydratedTemplateButton_HydratedURLButton::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.url)
+}
+
+// -------------------------------------------------------------------
+
+// HydratedTemplateButton
+
+// optional uint32 index = 4;
+inline bool HydratedTemplateButton::_internal_has_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HydratedTemplateButton::has_index() const {
+  return _internal_has_index();
+}
+inline void HydratedTemplateButton::clear_index() {
+  _impl_.index_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t HydratedTemplateButton::_internal_index() const {
+  return _impl_.index_;
+}
+inline uint32_t HydratedTemplateButton::index() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.index)
+  return _internal_index();
+}
+inline void HydratedTemplateButton::_internal_set_index(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.index_ = value;
+}
+inline void HydratedTemplateButton::set_index(uint32_t value) {
+  _internal_set_index(value);
+  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.index)
+}
+
+// .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
+inline bool HydratedTemplateButton::_internal_has_quickreplybutton() const {
+  return hydratedButton_case() == kQuickReplyButton;
+}
+inline bool HydratedTemplateButton::has_quickreplybutton() const {
+  return _internal_has_quickreplybutton();
+}
+inline void HydratedTemplateButton::set_has_quickreplybutton() {
+  _impl_._oneof_case_[0] = kQuickReplyButton;
+}
+inline void HydratedTemplateButton::clear_quickreplybutton() {
+  if (_internal_has_quickreplybutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.hydratedButton_.quickreplybutton_;
+    }
+    clear_has_hydratedButton();
+  }
+}
+inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::release_quickreplybutton() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.quickReplyButton)
+  if (_internal_has_quickreplybutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.hydratedButton_.quickreplybutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::_internal_quickreplybutton() const {
+  return _internal_has_quickreplybutton()
+      ? *_impl_.hydratedButton_.quickreplybutton_
+      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedQuickReplyButton&>(::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_);
+}
+inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::quickreplybutton() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.quickReplyButton)
+  return _internal_quickreplybutton();
+}
+inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::unsafe_arena_release_quickreplybutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.quickReplyButton)
+  if (_internal_has_quickreplybutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_;
+    _impl_.hydratedButton_.quickreplybutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void HydratedTemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) {
+  clear_hydratedButton();
+  if (quickreplybutton) {
+    set_has_quickreplybutton();
+    _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.quickReplyButton)
+}
+inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::_internal_mutable_quickreplybutton() {
+  if (!_internal_has_quickreplybutton()) {
+    clear_hydratedButton();
+    set_has_quickreplybutton();
+    _impl_.hydratedButton_.quickreplybutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(GetArenaForAllocation());
+  }
+  return _impl_.hydratedButton_.quickreplybutton_;
+}
+inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::mutable_quickreplybutton() {
+  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _msg = _internal_mutable_quickreplybutton();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.quickReplyButton)
+  return _msg;
+}
+
+// .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
+inline bool HydratedTemplateButton::_internal_has_urlbutton() const {
+  return hydratedButton_case() == kUrlButton;
+}
+inline bool HydratedTemplateButton::has_urlbutton() const {
+  return _internal_has_urlbutton();
+}
+inline void HydratedTemplateButton::set_has_urlbutton() {
+  _impl_._oneof_case_[0] = kUrlButton;
+}
+inline void HydratedTemplateButton::clear_urlbutton() {
+  if (_internal_has_urlbutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.hydratedButton_.urlbutton_;
+    }
+    clear_has_hydratedButton();
+  }
+}
+inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::release_urlbutton() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.urlButton)
+  if (_internal_has_urlbutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.hydratedButton_.urlbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::_internal_urlbutton() const {
+  return _internal_has_urlbutton()
+      ? *_impl_.hydratedButton_.urlbutton_
+      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedURLButton&>(::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_);
+}
+inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::urlbutton() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.urlButton)
+  return _internal_urlbutton();
+}
+inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::unsafe_arena_release_urlbutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.urlButton)
+  if (_internal_has_urlbutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_;
+    _impl_.hydratedButton_.urlbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void HydratedTemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) {
+  clear_hydratedButton();
+  if (urlbutton) {
+    set_has_urlbutton();
+    _impl_.hydratedButton_.urlbutton_ = urlbutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.urlButton)
+}
+inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::_internal_mutable_urlbutton() {
+  if (!_internal_has_urlbutton()) {
+    clear_hydratedButton();
+    set_has_urlbutton();
+    _impl_.hydratedButton_.urlbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(GetArenaForAllocation());
+  }
+  return _impl_.hydratedButton_.urlbutton_;
+}
+inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::mutable_urlbutton() {
+  ::proto::HydratedTemplateButton_HydratedURLButton* _msg = _internal_mutable_urlbutton();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.urlButton)
+  return _msg;
+}
+
+// .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
+inline bool HydratedTemplateButton::_internal_has_callbutton() const {
+  return hydratedButton_case() == kCallButton;
+}
+inline bool HydratedTemplateButton::has_callbutton() const {
+  return _internal_has_callbutton();
+}
+inline void HydratedTemplateButton::set_has_callbutton() {
+  _impl_._oneof_case_[0] = kCallButton;
+}
+inline void HydratedTemplateButton::clear_callbutton() {
+  if (_internal_has_callbutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.hydratedButton_.callbutton_;
+    }
+    clear_has_hydratedButton();
+  }
+}
+inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::release_callbutton() {
+  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.callButton)
+  if (_internal_has_callbutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.hydratedButton_.callbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::_internal_callbutton() const {
+  return _internal_has_callbutton()
+      ? *_impl_.hydratedButton_.callbutton_
+      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedCallButton&>(::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_);
+}
+inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::callbutton() const {
+  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.callButton)
+  return _internal_callbutton();
+}
+inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::unsafe_arena_release_callbutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.callButton)
+  if (_internal_has_callbutton()) {
+    clear_has_hydratedButton();
+    ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_;
+    _impl_.hydratedButton_.callbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void HydratedTemplateButton::unsafe_arena_set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) {
+  clear_hydratedButton();
+  if (callbutton) {
+    set_has_callbutton();
+    _impl_.hydratedButton_.callbutton_ = callbutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.callButton)
+}
+inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::_internal_mutable_callbutton() {
+  if (!_internal_has_callbutton()) {
+    clear_hydratedButton();
+    set_has_callbutton();
+    _impl_.hydratedButton_.callbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(GetArenaForAllocation());
+  }
+  return _impl_.hydratedButton_.callbutton_;
+}
+inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::mutable_callbutton() {
+  ::proto::HydratedTemplateButton_HydratedCallButton* _msg = _internal_mutable_callbutton();
+  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.callButton)
+  return _msg;
+}
+
+inline bool HydratedTemplateButton::has_hydratedButton() const {
+  return hydratedButton_case() != HYDRATEDBUTTON_NOT_SET;
+}
+inline void HydratedTemplateButton::clear_has_hydratedButton() {
+  _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET;
+}
+inline HydratedTemplateButton::HydratedButtonCase HydratedTemplateButton::hydratedButton_case() const {
+  return HydratedTemplateButton::HydratedButtonCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// IdentityKeyPairStructure
+
+// optional bytes publicKey = 1;
+inline bool IdentityKeyPairStructure::_internal_has_publickey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool IdentityKeyPairStructure::has_publickey() const {
+  return _internal_has_publickey();
+}
+inline void IdentityKeyPairStructure::clear_publickey() {
+  _impl_.publickey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& IdentityKeyPairStructure::publickey() const {
+  // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.publicKey)
+  return _internal_publickey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void IdentityKeyPairStructure::set_publickey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.publickey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.publicKey)
+}
+inline std::string* IdentityKeyPairStructure::mutable_publickey() {
+  std::string* _s = _internal_mutable_publickey();
+  // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.publicKey)
+  return _s;
+}
+inline const std::string& IdentityKeyPairStructure::_internal_publickey() const {
+  return _impl_.publickey_.Get();
+}
+inline void IdentityKeyPairStructure::_internal_set_publickey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.publickey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* IdentityKeyPairStructure::_internal_mutable_publickey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.publickey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* IdentityKeyPairStructure::release_publickey() {
+  // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.publicKey)
+  if (!_internal_has_publickey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.publickey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void IdentityKeyPairStructure::set_allocated_publickey(std::string* publickey) {
+  if (publickey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.publicKey)
+}
+
+// optional bytes privateKey = 2;
+inline bool IdentityKeyPairStructure::_internal_has_privatekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool IdentityKeyPairStructure::has_privatekey() const {
+  return _internal_has_privatekey();
+}
+inline void IdentityKeyPairStructure::clear_privatekey() {
+  _impl_.privatekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& IdentityKeyPairStructure::privatekey() const {
+  // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.privateKey)
+  return _internal_privatekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void IdentityKeyPairStructure::set_privatekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.privatekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.privateKey)
+}
+inline std::string* IdentityKeyPairStructure::mutable_privatekey() {
+  std::string* _s = _internal_mutable_privatekey();
+  // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.privateKey)
+  return _s;
+}
+inline const std::string& IdentityKeyPairStructure::_internal_privatekey() const {
+  return _impl_.privatekey_.Get();
+}
+inline void IdentityKeyPairStructure::_internal_set_privatekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.privatekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* IdentityKeyPairStructure::_internal_mutable_privatekey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* IdentityKeyPairStructure::release_privatekey() {
+  // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.privateKey)
+  if (!_internal_has_privatekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.privatekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void IdentityKeyPairStructure::set_allocated_privatekey(std::string* privatekey) {
+  if (privatekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.privateKey)
+}
+
+// -------------------------------------------------------------------
+
+// InteractiveAnnotation
+
+// repeated .proto.Point polygonVertices = 1;
+inline int InteractiveAnnotation::_internal_polygonvertices_size() const {
+  return _impl_.polygonvertices_.size();
+}
+inline int InteractiveAnnotation::polygonvertices_size() const {
+  return _internal_polygonvertices_size();
+}
+inline void InteractiveAnnotation::clear_polygonvertices() {
+  _impl_.polygonvertices_.Clear();
+}
+inline ::proto::Point* InteractiveAnnotation::mutable_polygonvertices(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.polygonVertices)
+  return _impl_.polygonvertices_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >*
+InteractiveAnnotation::mutable_polygonvertices() {
+  // @@protoc_insertion_point(field_mutable_list:proto.InteractiveAnnotation.polygonVertices)
+  return &_impl_.polygonvertices_;
+}
+inline const ::proto::Point& InteractiveAnnotation::_internal_polygonvertices(int index) const {
+  return _impl_.polygonvertices_.Get(index);
+}
+inline const ::proto::Point& InteractiveAnnotation::polygonvertices(int index) const {
+  // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.polygonVertices)
+  return _internal_polygonvertices(index);
+}
+inline ::proto::Point* InteractiveAnnotation::_internal_add_polygonvertices() {
+  return _impl_.polygonvertices_.Add();
+}
+inline ::proto::Point* InteractiveAnnotation::add_polygonvertices() {
+  ::proto::Point* _add = _internal_add_polygonvertices();
+  // @@protoc_insertion_point(field_add:proto.InteractiveAnnotation.polygonVertices)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >&
+InteractiveAnnotation::polygonvertices() const {
+  // @@protoc_insertion_point(field_list:proto.InteractiveAnnotation.polygonVertices)
+  return _impl_.polygonvertices_;
+}
+
+// .proto.Location location = 2;
+inline bool InteractiveAnnotation::_internal_has_location() const {
+  return action_case() == kLocation;
+}
+inline bool InteractiveAnnotation::has_location() const {
+  return _internal_has_location();
+}
+inline void InteractiveAnnotation::set_has_location() {
+  _impl_._oneof_case_[0] = kLocation;
+}
+inline void InteractiveAnnotation::clear_location() {
+  if (_internal_has_location()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.action_.location_;
+    }
+    clear_has_action();
+  }
+}
+inline ::proto::Location* InteractiveAnnotation::release_location() {
+  // @@protoc_insertion_point(field_release:proto.InteractiveAnnotation.location)
+  if (_internal_has_location()) {
+    clear_has_action();
+    ::proto::Location* temp = _impl_.action_.location_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.action_.location_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Location& InteractiveAnnotation::_internal_location() const {
+  return _internal_has_location()
+      ? *_impl_.action_.location_
+      : reinterpret_cast< ::proto::Location&>(::proto::_Location_default_instance_);
+}
+inline const ::proto::Location& InteractiveAnnotation::location() const {
+  // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.location)
+  return _internal_location();
+}
+inline ::proto::Location* InteractiveAnnotation::unsafe_arena_release_location() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.InteractiveAnnotation.location)
+  if (_internal_has_location()) {
+    clear_has_action();
+    ::proto::Location* temp = _impl_.action_.location_;
+    _impl_.action_.location_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void InteractiveAnnotation::unsafe_arena_set_allocated_location(::proto::Location* location) {
+  clear_action();
+  if (location) {
+    set_has_location();
+    _impl_.action_.location_ = location;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.InteractiveAnnotation.location)
+}
+inline ::proto::Location* InteractiveAnnotation::_internal_mutable_location() {
+  if (!_internal_has_location()) {
+    clear_action();
+    set_has_location();
+    _impl_.action_.location_ = CreateMaybeMessage< ::proto::Location >(GetArenaForAllocation());
+  }
+  return _impl_.action_.location_;
+}
+inline ::proto::Location* InteractiveAnnotation::mutable_location() {
+  ::proto::Location* _msg = _internal_mutable_location();
+  // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.location)
+  return _msg;
+}
+
+inline bool InteractiveAnnotation::has_action() const {
+  return action_case() != ACTION_NOT_SET;
+}
+inline void InteractiveAnnotation::clear_has_action() {
+  _impl_._oneof_case_[0] = ACTION_NOT_SET;
+}
+inline InteractiveAnnotation::ActionCase InteractiveAnnotation::action_case() const {
+  return InteractiveAnnotation::ActionCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// KeepInChat
+
+// optional .proto.KeepType keepType = 1;
+inline bool KeepInChat::_internal_has_keeptype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool KeepInChat::has_keeptype() const {
+  return _internal_has_keeptype();
+}
+inline void KeepInChat::clear_keeptype() {
+  _impl_.keeptype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::KeepType KeepInChat::_internal_keeptype() const {
+  return static_cast< ::proto::KeepType >(_impl_.keeptype_);
+}
+inline ::proto::KeepType KeepInChat::keeptype() const {
+  // @@protoc_insertion_point(field_get:proto.KeepInChat.keepType)
+  return _internal_keeptype();
+}
+inline void KeepInChat::_internal_set_keeptype(::proto::KeepType value) {
+  assert(::proto::KeepType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.keeptype_ = value;
+}
+inline void KeepInChat::set_keeptype(::proto::KeepType value) {
+  _internal_set_keeptype(value);
+  // @@protoc_insertion_point(field_set:proto.KeepInChat.keepType)
+}
+
+// optional int64 serverTimestamp = 2;
+inline bool KeepInChat::_internal_has_servertimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool KeepInChat::has_servertimestamp() const {
+  return _internal_has_servertimestamp();
+}
+inline void KeepInChat::clear_servertimestamp() {
+  _impl_.servertimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t KeepInChat::_internal_servertimestamp() const {
+  return _impl_.servertimestamp_;
+}
+inline int64_t KeepInChat::servertimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.KeepInChat.serverTimestamp)
+  return _internal_servertimestamp();
+}
+inline void KeepInChat::_internal_set_servertimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.servertimestamp_ = value;
+}
+inline void KeepInChat::set_servertimestamp(int64_t value) {
+  _internal_set_servertimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.KeepInChat.serverTimestamp)
+}
+
+// optional .proto.MessageKey key = 3;
+inline bool KeepInChat::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool KeepInChat::has_key() const {
+  return _internal_has_key();
+}
+inline void KeepInChat::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::MessageKey& KeepInChat::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& KeepInChat::key() const {
+  // @@protoc_insertion_point(field_get:proto.KeepInChat.key)
+  return _internal_key();
+}
+inline void KeepInChat::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.KeepInChat.key)
+}
+inline ::proto::MessageKey* KeepInChat::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* KeepInChat::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.KeepInChat.key)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* KeepInChat::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* KeepInChat::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.KeepInChat.key)
+  return _msg;
+}
+inline void KeepInChat::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.key)
+}
+
+// optional string deviceJid = 4;
+inline bool KeepInChat::_internal_has_devicejid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeepInChat::has_devicejid() const {
+  return _internal_has_devicejid();
+}
+inline void KeepInChat::clear_devicejid() {
+  _impl_.devicejid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeepInChat::devicejid() const {
+  // @@protoc_insertion_point(field_get:proto.KeepInChat.deviceJid)
+  return _internal_devicejid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeepInChat::set_devicejid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.devicejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.KeepInChat.deviceJid)
+}
+inline std::string* KeepInChat::mutable_devicejid() {
+  std::string* _s = _internal_mutable_devicejid();
+  // @@protoc_insertion_point(field_mutable:proto.KeepInChat.deviceJid)
+  return _s;
+}
+inline const std::string& KeepInChat::_internal_devicejid() const {
+  return _impl_.devicejid_.Get();
+}
+inline void KeepInChat::_internal_set_devicejid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.devicejid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KeepInChat::_internal_mutable_devicejid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.devicejid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KeepInChat::release_devicejid() {
+  // @@protoc_insertion_point(field_release:proto.KeepInChat.deviceJid)
+  if (!_internal_has_devicejid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.devicejid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.devicejid_.IsDefault()) {
+    _impl_.devicejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void KeepInChat::set_allocated_devicejid(std::string* devicejid) {
+  if (devicejid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.devicejid_.SetAllocated(devicejid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.devicejid_.IsDefault()) {
+    _impl_.devicejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.deviceJid)
+}
+
+// -------------------------------------------------------------------
+
+// KeyId
+
+// optional bytes id = 1;
+inline bool KeyId::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeyId::has_id() const {
+  return _internal_has_id();
+}
+inline void KeyId::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeyId::id() const {
+  // @@protoc_insertion_point(field_get:proto.KeyId.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyId::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.KeyId.id)
+}
+inline std::string* KeyId::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.KeyId.id)
+  return _s;
+}
+inline const std::string& KeyId::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void KeyId::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KeyId::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KeyId::release_id() {
+  // @@protoc_insertion_point(field_release:proto.KeyId.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void KeyId::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.KeyId.id)
+}
+
+// -------------------------------------------------------------------
+
+// LocalizedName
+
+// optional string lg = 1;
+inline bool LocalizedName::_internal_has_lg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LocalizedName::has_lg() const {
+  return _internal_has_lg();
+}
+inline void LocalizedName::clear_lg() {
+  _impl_.lg_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LocalizedName::lg() const {
+  // @@protoc_insertion_point(field_get:proto.LocalizedName.lg)
+  return _internal_lg();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LocalizedName::set_lg(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.lg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.LocalizedName.lg)
+}
+inline std::string* LocalizedName::mutable_lg() {
+  std::string* _s = _internal_mutable_lg();
+  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lg)
+  return _s;
+}
+inline const std::string& LocalizedName::_internal_lg() const {
+  return _impl_.lg_.Get();
+}
+inline void LocalizedName::_internal_set_lg(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.lg_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LocalizedName::_internal_mutable_lg() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.lg_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LocalizedName::release_lg() {
+  // @@protoc_insertion_point(field_release:proto.LocalizedName.lg)
+  if (!_internal_has_lg()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.lg_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.lg_.IsDefault()) {
+    _impl_.lg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LocalizedName::set_allocated_lg(std::string* lg) {
+  if (lg != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.lg_.SetAllocated(lg, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.lg_.IsDefault()) {
+    _impl_.lg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lg)
+}
+
+// optional string lc = 2;
+inline bool LocalizedName::_internal_has_lc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LocalizedName::has_lc() const {
+  return _internal_has_lc();
+}
+inline void LocalizedName::clear_lc() {
+  _impl_.lc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LocalizedName::lc() const {
+  // @@protoc_insertion_point(field_get:proto.LocalizedName.lc)
+  return _internal_lc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LocalizedName::set_lc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.lc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.LocalizedName.lc)
+}
+inline std::string* LocalizedName::mutable_lc() {
+  std::string* _s = _internal_mutable_lc();
+  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lc)
+  return _s;
+}
+inline const std::string& LocalizedName::_internal_lc() const {
+  return _impl_.lc_.Get();
+}
+inline void LocalizedName::_internal_set_lc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.lc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LocalizedName::_internal_mutable_lc() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.lc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LocalizedName::release_lc() {
+  // @@protoc_insertion_point(field_release:proto.LocalizedName.lc)
+  if (!_internal_has_lc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.lc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.lc_.IsDefault()) {
+    _impl_.lc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LocalizedName::set_allocated_lc(std::string* lc) {
+  if (lc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.lc_.SetAllocated(lc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.lc_.IsDefault()) {
+    _impl_.lc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lc)
+}
+
+// optional string verifiedName = 3;
+inline bool LocalizedName::_internal_has_verifiedname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LocalizedName::has_verifiedname() const {
+  return _internal_has_verifiedname();
+}
+inline void LocalizedName::clear_verifiedname() {
+  _impl_.verifiedname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& LocalizedName::verifiedname() const {
+  // @@protoc_insertion_point(field_get:proto.LocalizedName.verifiedName)
+  return _internal_verifiedname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LocalizedName::set_verifiedname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.verifiedname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.LocalizedName.verifiedName)
+}
+inline std::string* LocalizedName::mutable_verifiedname() {
+  std::string* _s = _internal_mutable_verifiedname();
+  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.verifiedName)
+  return _s;
+}
+inline const std::string& LocalizedName::_internal_verifiedname() const {
+  return _impl_.verifiedname_.Get();
+}
+inline void LocalizedName::_internal_set_verifiedname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.verifiedname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LocalizedName::_internal_mutable_verifiedname() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.verifiedname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LocalizedName::release_verifiedname() {
+  // @@protoc_insertion_point(field_release:proto.LocalizedName.verifiedName)
+  if (!_internal_has_verifiedname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.verifiedname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedname_.IsDefault()) {
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LocalizedName::set_allocated_verifiedname(std::string* verifiedname) {
+  if (verifiedname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedname_.IsDefault()) {
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.verifiedName)
+}
+
+// -------------------------------------------------------------------
+
+// Location
+
+// optional double degreesLatitude = 1;
+inline bool Location::_internal_has_degreeslatitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Location::has_degreeslatitude() const {
+  return _internal_has_degreeslatitude();
+}
+inline void Location::clear_degreeslatitude() {
+  _impl_.degreeslatitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline double Location::_internal_degreeslatitude() const {
+  return _impl_.degreeslatitude_;
+}
+inline double Location::degreeslatitude() const {
+  // @@protoc_insertion_point(field_get:proto.Location.degreesLatitude)
+  return _internal_degreeslatitude();
+}
+inline void Location::_internal_set_degreeslatitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.degreeslatitude_ = value;
+}
+inline void Location::set_degreeslatitude(double value) {
+  _internal_set_degreeslatitude(value);
+  // @@protoc_insertion_point(field_set:proto.Location.degreesLatitude)
+}
+
+// optional double degreesLongitude = 2;
+inline bool Location::_internal_has_degreeslongitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Location::has_degreeslongitude() const {
+  return _internal_has_degreeslongitude();
+}
+inline void Location::clear_degreeslongitude() {
+  _impl_.degreeslongitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline double Location::_internal_degreeslongitude() const {
+  return _impl_.degreeslongitude_;
+}
+inline double Location::degreeslongitude() const {
+  // @@protoc_insertion_point(field_get:proto.Location.degreesLongitude)
+  return _internal_degreeslongitude();
+}
+inline void Location::_internal_set_degreeslongitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.degreeslongitude_ = value;
+}
+inline void Location::set_degreeslongitude(double value) {
+  _internal_set_degreeslongitude(value);
+  // @@protoc_insertion_point(field_set:proto.Location.degreesLongitude)
+}
+
+// optional string name = 3;
+inline bool Location::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Location::has_name() const {
+  return _internal_has_name();
+}
+inline void Location::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Location::name() const {
+  // @@protoc_insertion_point(field_get:proto.Location.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Location::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Location.name)
+}
+inline std::string* Location::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Location.name)
+  return _s;
+}
+inline const std::string& Location::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Location::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Location::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Location::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Location.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Location::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Location.name)
+}
+
+// -------------------------------------------------------------------
+
+// MediaData
+
+// optional string localPath = 1;
+inline bool MediaData::_internal_has_localpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MediaData::has_localpath() const {
+  return _internal_has_localpath();
+}
+inline void MediaData::clear_localpath() {
+  _impl_.localpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MediaData::localpath() const {
+  // @@protoc_insertion_point(field_get:proto.MediaData.localPath)
+  return _internal_localpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MediaData::set_localpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.localpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MediaData.localPath)
+}
+inline std::string* MediaData::mutable_localpath() {
+  std::string* _s = _internal_mutable_localpath();
+  // @@protoc_insertion_point(field_mutable:proto.MediaData.localPath)
+  return _s;
+}
+inline const std::string& MediaData::_internal_localpath() const {
+  return _impl_.localpath_.Get();
+}
+inline void MediaData::_internal_set_localpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.localpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MediaData::_internal_mutable_localpath() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.localpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MediaData::release_localpath() {
+  // @@protoc_insertion_point(field_release:proto.MediaData.localPath)
+  if (!_internal_has_localpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.localpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localpath_.IsDefault()) {
+    _impl_.localpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MediaData::set_allocated_localpath(std::string* localpath) {
+  if (localpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.localpath_.SetAllocated(localpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localpath_.IsDefault()) {
+    _impl_.localpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MediaData.localPath)
+}
+
+// -------------------------------------------------------------------
+
+// MediaRetryNotification
+
+// optional string stanzaId = 1;
+inline bool MediaRetryNotification::_internal_has_stanzaid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MediaRetryNotification::has_stanzaid() const {
+  return _internal_has_stanzaid();
+}
+inline void MediaRetryNotification::clear_stanzaid() {
+  _impl_.stanzaid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MediaRetryNotification::stanzaid() const {
+  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.stanzaId)
+  return _internal_stanzaid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MediaRetryNotification::set_stanzaid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.stanzaId)
+}
+inline std::string* MediaRetryNotification::mutable_stanzaid() {
+  std::string* _s = _internal_mutable_stanzaid();
+  // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.stanzaId)
+  return _s;
+}
+inline const std::string& MediaRetryNotification::_internal_stanzaid() const {
+  return _impl_.stanzaid_.Get();
+}
+inline void MediaRetryNotification::_internal_set_stanzaid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MediaRetryNotification::_internal_mutable_stanzaid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MediaRetryNotification::release_stanzaid() {
+  // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.stanzaId)
+  if (!_internal_has_stanzaid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.stanzaid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MediaRetryNotification::set_allocated_stanzaid(std::string* stanzaid) {
+  if (stanzaid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.stanzaId)
+}
+
+// optional string directPath = 2;
+inline bool MediaRetryNotification::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MediaRetryNotification::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void MediaRetryNotification::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MediaRetryNotification::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MediaRetryNotification::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.directPath)
+}
+inline std::string* MediaRetryNotification::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.directPath)
+  return _s;
+}
+inline const std::string& MediaRetryNotification::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void MediaRetryNotification::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MediaRetryNotification::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MediaRetryNotification::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MediaRetryNotification::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.directPath)
+}
+
+// optional .proto.MediaRetryNotification.ResultType result = 3;
+inline bool MediaRetryNotification::_internal_has_result() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MediaRetryNotification::has_result() const {
+  return _internal_has_result();
+}
+inline void MediaRetryNotification::clear_result() {
+  _impl_.result_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::_internal_result() const {
+  return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.result_);
+}
+inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::result() const {
+  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.result)
+  return _internal_result();
+}
+inline void MediaRetryNotification::_internal_set_result(::proto::MediaRetryNotification_ResultType value) {
+  assert(::proto::MediaRetryNotification_ResultType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.result_ = value;
+}
+inline void MediaRetryNotification::set_result(::proto::MediaRetryNotification_ResultType value) {
+  _internal_set_result(value);
+  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.result)
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateFatalExceptionNotification
+
+// repeated string collectionNames = 1;
+inline int Message_AppStateFatalExceptionNotification::_internal_collectionnames_size() const {
+  return _impl_.collectionnames_.size();
+}
+inline int Message_AppStateFatalExceptionNotification::collectionnames_size() const {
+  return _internal_collectionnames_size();
+}
+inline void Message_AppStateFatalExceptionNotification::clear_collectionnames() {
+  _impl_.collectionnames_.Clear();
+}
+inline std::string* Message_AppStateFatalExceptionNotification::add_collectionnames() {
+  std::string* _s = _internal_add_collectionnames();
+  // @@protoc_insertion_point(field_add_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+  return _s;
+}
+inline const std::string& Message_AppStateFatalExceptionNotification::_internal_collectionnames(int index) const {
+  return _impl_.collectionnames_.Get(index);
+}
+inline const std::string& Message_AppStateFatalExceptionNotification::collectionnames(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+  return _internal_collectionnames(index);
+}
+inline std::string* Message_AppStateFatalExceptionNotification::mutable_collectionnames(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+  return _impl_.collectionnames_.Mutable(index);
+}
+inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const std::string& value) {
+  _impl_.collectionnames_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, std::string&& value) {
+  _impl_.collectionnames_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.collectionnames_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value, size_t size) {
+  _impl_.collectionnames_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline std::string* Message_AppStateFatalExceptionNotification::_internal_add_collectionnames() {
+  return _impl_.collectionnames_.Add();
+}
+inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const std::string& value) {
+  _impl_.collectionnames_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::add_collectionnames(std::string&& value) {
+  _impl_.collectionnames_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.collectionnames_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value, size_t size) {
+  _impl_.collectionnames_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Message_AppStateFatalExceptionNotification::collectionnames() const {
+  // @@protoc_insertion_point(field_list:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+  return _impl_.collectionnames_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Message_AppStateFatalExceptionNotification::mutable_collectionnames() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateFatalExceptionNotification.collectionNames)
+  return &_impl_.collectionnames_;
+}
+
+// optional int64 timestamp = 2;
+inline bool Message_AppStateFatalExceptionNotification::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_AppStateFatalExceptionNotification::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void Message_AppStateFatalExceptionNotification::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t Message_AppStateFatalExceptionNotification::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t Message_AppStateFatalExceptionNotification::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.timestamp)
+  return _internal_timestamp();
+}
+inline void Message_AppStateFatalExceptionNotification::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void Message_AppStateFatalExceptionNotification::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKeyData
+
+// optional bytes keyData = 1;
+inline bool Message_AppStateSyncKeyData::_internal_has_keydata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_AppStateSyncKeyData::has_keydata() const {
+  return _internal_has_keydata();
+}
+inline void Message_AppStateSyncKeyData::clear_keydata() {
+  _impl_.keydata_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_AppStateSyncKeyData::keydata() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.keyData)
+  return _internal_keydata();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AppStateSyncKeyData::set_keydata(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.keydata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.keyData)
+}
+inline std::string* Message_AppStateSyncKeyData::mutable_keydata() {
+  std::string* _s = _internal_mutable_keydata();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.keyData)
+  return _s;
+}
+inline const std::string& Message_AppStateSyncKeyData::_internal_keydata() const {
+  return _impl_.keydata_.Get();
+}
+inline void Message_AppStateSyncKeyData::_internal_set_keydata(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.keydata_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AppStateSyncKeyData::_internal_mutable_keydata() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.keydata_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AppStateSyncKeyData::release_keydata() {
+  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.keyData)
+  if (!_internal_has_keydata()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.keydata_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.keydata_.IsDefault()) {
+    _impl_.keydata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AppStateSyncKeyData::set_allocated_keydata(std::string* keydata) {
+  if (keydata != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.keydata_.SetAllocated(keydata, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.keydata_.IsDefault()) {
+    _impl_.keydata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.keyData)
+}
+
+// optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
+inline bool Message_AppStateSyncKeyData::_internal_has_fingerprint() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.fingerprint_ != nullptr);
+  return value;
+}
+inline bool Message_AppStateSyncKeyData::has_fingerprint() const {
+  return _internal_has_fingerprint();
+}
+inline void Message_AppStateSyncKeyData::clear_fingerprint() {
+  if (_impl_.fingerprint_ != nullptr) _impl_.fingerprint_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::_internal_fingerprint() const {
+  const ::proto::Message_AppStateSyncKeyFingerprint* p = _impl_.fingerprint_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyFingerprint&>(
+      ::proto::_Message_AppStateSyncKeyFingerprint_default_instance_);
+}
+inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::fingerprint() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.fingerprint)
+  return _internal_fingerprint();
+}
+inline void Message_AppStateSyncKeyData::unsafe_arena_set_allocated_fingerprint(
+    ::proto::Message_AppStateSyncKeyFingerprint* fingerprint) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fingerprint_);
+  }
+  _impl_.fingerprint_ = fingerprint;
+  if (fingerprint) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint)
+}
+inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::release_fingerprint() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_;
+  _impl_.fingerprint_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::unsafe_arena_release_fingerprint() {
+  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.fingerprint)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_;
+  _impl_.fingerprint_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::_internal_mutable_fingerprint() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.fingerprint_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(GetArenaForAllocation());
+    _impl_.fingerprint_ = p;
+  }
+  return _impl_.fingerprint_;
+}
+inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::mutable_fingerprint() {
+  ::proto::Message_AppStateSyncKeyFingerprint* _msg = _internal_mutable_fingerprint();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.fingerprint)
+  return _msg;
+}
+inline void Message_AppStateSyncKeyData::set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.fingerprint_;
+  }
+  if (fingerprint) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fingerprint);
+    if (message_arena != submessage_arena) {
+      fingerprint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fingerprint, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.fingerprint_ = fingerprint;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint)
+}
+
+// optional int64 timestamp = 3;
+inline bool Message_AppStateSyncKeyData::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_AppStateSyncKeyData::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void Message_AppStateSyncKeyData::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t Message_AppStateSyncKeyData::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t Message_AppStateSyncKeyData::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.timestamp)
+  return _internal_timestamp();
+}
+inline void Message_AppStateSyncKeyData::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.timestamp_ = value;
+}
+inline void Message_AppStateSyncKeyData::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKeyFingerprint
+
+// optional uint32 rawId = 1;
+inline bool Message_AppStateSyncKeyFingerprint::_internal_has_rawid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_AppStateSyncKeyFingerprint::has_rawid() const {
+  return _internal_has_rawid();
+}
+inline void Message_AppStateSyncKeyFingerprint::clear_rawid() {
+  _impl_.rawid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_rawid() const {
+  return _impl_.rawid_;
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::rawid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.rawId)
+  return _internal_rawid();
+}
+inline void Message_AppStateSyncKeyFingerprint::_internal_set_rawid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.rawid_ = value;
+}
+inline void Message_AppStateSyncKeyFingerprint::set_rawid(uint32_t value) {
+  _internal_set_rawid(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.rawId)
+}
+
+// optional uint32 currentIndex = 2;
+inline bool Message_AppStateSyncKeyFingerprint::_internal_has_currentindex() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_AppStateSyncKeyFingerprint::has_currentindex() const {
+  return _internal_has_currentindex();
+}
+inline void Message_AppStateSyncKeyFingerprint::clear_currentindex() {
+  _impl_.currentindex_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_currentindex() const {
+  return _impl_.currentindex_;
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::currentindex() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.currentIndex)
+  return _internal_currentindex();
+}
+inline void Message_AppStateSyncKeyFingerprint::_internal_set_currentindex(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.currentindex_ = value;
+}
+inline void Message_AppStateSyncKeyFingerprint::set_currentindex(uint32_t value) {
+  _internal_set_currentindex(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.currentIndex)
+}
+
+// repeated uint32 deviceIndexes = 3 [packed = true];
+inline int Message_AppStateSyncKeyFingerprint::_internal_deviceindexes_size() const {
+  return _impl_.deviceindexes_.size();
+}
+inline int Message_AppStateSyncKeyFingerprint::deviceindexes_size() const {
+  return _internal_deviceindexes_size();
+}
+inline void Message_AppStateSyncKeyFingerprint::clear_deviceindexes() {
+  _impl_.deviceindexes_.Clear();
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_deviceindexes(int index) const {
+  return _impl_.deviceindexes_.Get(index);
+}
+inline uint32_t Message_AppStateSyncKeyFingerprint::deviceindexes(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
+  return _internal_deviceindexes(index);
+}
+inline void Message_AppStateSyncKeyFingerprint::set_deviceindexes(int index, uint32_t value) {
+  _impl_.deviceindexes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
+}
+inline void Message_AppStateSyncKeyFingerprint::_internal_add_deviceindexes(uint32_t value) {
+  _impl_.deviceindexes_.Add(value);
+}
+inline void Message_AppStateSyncKeyFingerprint::add_deviceindexes(uint32_t value) {
+  _internal_add_deviceindexes(value);
+  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+Message_AppStateSyncKeyFingerprint::_internal_deviceindexes() const {
+  return _impl_.deviceindexes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+Message_AppStateSyncKeyFingerprint::deviceindexes() const {
+  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
+  return _internal_deviceindexes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+Message_AppStateSyncKeyFingerprint::_internal_mutable_deviceindexes() {
+  return &_impl_.deviceindexes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+Message_AppStateSyncKeyFingerprint::mutable_deviceindexes() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
+  return _internal_mutable_deviceindexes();
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKeyId
+
+// optional bytes keyId = 1;
+inline bool Message_AppStateSyncKeyId::_internal_has_keyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_AppStateSyncKeyId::has_keyid() const {
+  return _internal_has_keyid();
+}
+inline void Message_AppStateSyncKeyId::clear_keyid() {
+  _impl_.keyid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_AppStateSyncKeyId::keyid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyId.keyId)
+  return _internal_keyid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AppStateSyncKeyId::set_keyid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.keyid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyId.keyId)
+}
+inline std::string* Message_AppStateSyncKeyId::mutable_keyid() {
+  std::string* _s = _internal_mutable_keyid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyId.keyId)
+  return _s;
+}
+inline const std::string& Message_AppStateSyncKeyId::_internal_keyid() const {
+  return _impl_.keyid_.Get();
+}
+inline void Message_AppStateSyncKeyId::_internal_set_keyid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.keyid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AppStateSyncKeyId::_internal_mutable_keyid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.keyid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AppStateSyncKeyId::release_keyid() {
+  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyId.keyId)
+  if (!_internal_has_keyid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.keyid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.keyid_.IsDefault()) {
+    _impl_.keyid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AppStateSyncKeyId::set_allocated_keyid(std::string* keyid) {
+  if (keyid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.keyid_.SetAllocated(keyid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.keyid_.IsDefault()) {
+    _impl_.keyid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyId.keyId)
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKeyRequest
+
+// repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
+inline int Message_AppStateSyncKeyRequest::_internal_keyids_size() const {
+  return _impl_.keyids_.size();
+}
+inline int Message_AppStateSyncKeyRequest::keyids_size() const {
+  return _internal_keyids_size();
+}
+inline void Message_AppStateSyncKeyRequest::clear_keyids() {
+  _impl_.keyids_.Clear();
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::mutable_keyids(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyRequest.keyIds)
+  return _impl_.keyids_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >*
+Message_AppStateSyncKeyRequest::mutable_keyids() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyRequest.keyIds)
+  return &_impl_.keyids_;
+}
+inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::_internal_keyids(int index) const {
+  return _impl_.keyids_.Get(index);
+}
+inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::keyids(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyRequest.keyIds)
+  return _internal_keyids(index);
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::_internal_add_keyids() {
+  return _impl_.keyids_.Add();
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::add_keyids() {
+  ::proto::Message_AppStateSyncKeyId* _add = _internal_add_keyids();
+  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyRequest.keyIds)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >&
+Message_AppStateSyncKeyRequest::keyids() const {
+  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyRequest.keyIds)
+  return _impl_.keyids_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKeyShare
+
+// repeated .proto.Message.AppStateSyncKey keys = 1;
+inline int Message_AppStateSyncKeyShare::_internal_keys_size() const {
+  return _impl_.keys_.size();
+}
+inline int Message_AppStateSyncKeyShare::keys_size() const {
+  return _internal_keys_size();
+}
+inline void Message_AppStateSyncKeyShare::clear_keys() {
+  _impl_.keys_.Clear();
+}
+inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::mutable_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyShare.keys)
+  return _impl_.keys_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >*
+Message_AppStateSyncKeyShare::mutable_keys() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyShare.keys)
+  return &_impl_.keys_;
+}
+inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::_internal_keys(int index) const {
+  return _impl_.keys_.Get(index);
+}
+inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::keys(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyShare.keys)
+  return _internal_keys(index);
+}
+inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::_internal_add_keys() {
+  return _impl_.keys_.Add();
+}
+inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::add_keys() {
+  ::proto::Message_AppStateSyncKey* _add = _internal_add_keys();
+  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyShare.keys)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >&
+Message_AppStateSyncKeyShare::keys() const {
+  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyShare.keys)
+  return _impl_.keys_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_AppStateSyncKey
+
+// optional .proto.Message.AppStateSyncKeyId keyId = 1;
+inline bool Message_AppStateSyncKey::_internal_has_keyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
+  return value;
+}
+inline bool Message_AppStateSyncKey::has_keyid() const {
+  return _internal_has_keyid();
+}
+inline void Message_AppStateSyncKey::clear_keyid() {
+  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::_internal_keyid() const {
+  const ::proto::Message_AppStateSyncKeyId* p = _impl_.keyid_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyId&>(
+      ::proto::_Message_AppStateSyncKeyId_default_instance_);
+}
+inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::keyid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyId)
+  return _internal_keyid();
+}
+inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keyid(
+    ::proto::Message_AppStateSyncKeyId* keyid) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
+  }
+  _impl_.keyid_ = keyid;
+  if (keyid) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyId)
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::release_keyid() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::unsafe_arena_release_keyid() {
+  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyId)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::_internal_mutable_keyid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.keyid_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(GetArenaForAllocation());
+    _impl_.keyid_ = p;
+  }
+  return _impl_.keyid_;
+}
+inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::mutable_keyid() {
+  ::proto::Message_AppStateSyncKeyId* _msg = _internal_mutable_keyid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyId)
+  return _msg;
+}
+inline void Message_AppStateSyncKey::set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keyid_;
+  }
+  if (keyid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
+    if (message_arena != submessage_arena) {
+      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keyid, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.keyid_ = keyid;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyId)
+}
+
+// optional .proto.Message.AppStateSyncKeyData keyData = 2;
+inline bool Message_AppStateSyncKey::_internal_has_keydata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keydata_ != nullptr);
+  return value;
+}
+inline bool Message_AppStateSyncKey::has_keydata() const {
+  return _internal_has_keydata();
+}
+inline void Message_AppStateSyncKey::clear_keydata() {
+  if (_impl_.keydata_ != nullptr) _impl_.keydata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::_internal_keydata() const {
+  const ::proto::Message_AppStateSyncKeyData* p = _impl_.keydata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyData&>(
+      ::proto::_Message_AppStateSyncKeyData_default_instance_);
+}
+inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::keydata() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyData)
+  return _internal_keydata();
+}
+inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keydata(
+    ::proto::Message_AppStateSyncKeyData* keydata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keydata_);
+  }
+  _impl_.keydata_ = keydata;
+  if (keydata) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyData)
+}
+inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::release_keydata() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_;
+  _impl_.keydata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::unsafe_arena_release_keydata() {
+  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyData)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_;
+  _impl_.keydata_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::_internal_mutable_keydata() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.keydata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(GetArenaForAllocation());
+    _impl_.keydata_ = p;
+  }
+  return _impl_.keydata_;
+}
+inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::mutable_keydata() {
+  ::proto::Message_AppStateSyncKeyData* _msg = _internal_mutable_keydata();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyData)
+  return _msg;
+}
+inline void Message_AppStateSyncKey::set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keydata_;
+  }
+  if (keydata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keydata);
+    if (message_arena != submessage_arena) {
+      keydata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keydata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.keydata_ = keydata;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyData)
+}
+
+// -------------------------------------------------------------------
+
+// Message_AudioMessage
+
+// optional string url = 1;
+inline bool Message_AudioMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_AudioMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_AudioMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.url)
+}
+inline std::string* Message_AudioMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.url)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_AudioMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.url)
+}
+
+// optional string mimetype = 2;
+inline bool Message_AudioMessage::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void Message_AudioMessage::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_AudioMessage::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mimetype)
+}
+inline std::string* Message_AudioMessage::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mimetype)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void Message_AudioMessage::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mimetype)
+}
+
+// optional bytes fileSha256 = 3;
+inline bool Message_AudioMessage::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_AudioMessage::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_AudioMessage::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileSha256)
+}
+inline std::string* Message_AudioMessage::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_AudioMessage::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileSha256)
+}
+
+// optional uint64 fileLength = 4;
+inline bool Message_AudioMessage::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_AudioMessage::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint64_t Message_AudioMessage::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_AudioMessage::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileLength)
+  return _internal_filelength();
+}
+inline void Message_AudioMessage::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.filelength_ = value;
+}
+inline void Message_AudioMessage::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileLength)
+}
+
+// optional uint32 seconds = 5;
+inline bool Message_AudioMessage::_internal_has_seconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_seconds() const {
+  return _internal_has_seconds();
+}
+inline void Message_AudioMessage::clear_seconds() {
+  _impl_.seconds_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline uint32_t Message_AudioMessage::_internal_seconds() const {
+  return _impl_.seconds_;
+}
+inline uint32_t Message_AudioMessage::seconds() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.seconds)
+  return _internal_seconds();
+}
+inline void Message_AudioMessage::_internal_set_seconds(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.seconds_ = value;
+}
+inline void Message_AudioMessage::set_seconds(uint32_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.seconds)
+}
+
+// optional bool ptt = 6;
+inline bool Message_AudioMessage::_internal_has_ptt() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_ptt() const {
+  return _internal_has_ptt();
+}
+inline void Message_AudioMessage::clear_ptt() {
+  _impl_.ptt_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool Message_AudioMessage::_internal_ptt() const {
+  return _impl_.ptt_;
+}
+inline bool Message_AudioMessage::ptt() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.ptt)
+  return _internal_ptt();
+}
+inline void Message_AudioMessage::_internal_set_ptt(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.ptt_ = value;
+}
+inline void Message_AudioMessage::set_ptt(bool value) {
+  _internal_set_ptt(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.ptt)
+}
+
+// optional bytes mediaKey = 7;
+inline bool Message_AudioMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_AudioMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_AudioMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKey)
+}
+inline std::string* Message_AudioMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_AudioMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mediaKey)
+}
+
+// optional bytes fileEncSha256 = 8;
+inline bool Message_AudioMessage::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_AudioMessage::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_AudioMessage::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileEncSha256)
+}
+inline std::string* Message_AudioMessage::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_AudioMessage::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileEncSha256)
+}
+
+// optional string directPath = 9;
+inline bool Message_AudioMessage::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_AudioMessage::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_AudioMessage::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.directPath)
+}
+inline std::string* Message_AudioMessage::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.directPath)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_AudioMessage::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.directPath)
+}
+
+// optional int64 mediaKeyTimestamp = 10;
+inline bool Message_AudioMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_AudioMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline int64_t Message_AudioMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_AudioMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_AudioMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_AudioMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKeyTimestamp)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_AudioMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_AudioMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_AudioMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::ContextInfo& Message_AudioMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_AudioMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_AudioMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AudioMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_AudioMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_AudioMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_AudioMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_AudioMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.contextInfo)
+  return _msg;
+}
+inline void Message_AudioMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.contextInfo)
+}
+
+// optional bytes streamingSidecar = 18;
+inline bool Message_AudioMessage::_internal_has_streamingsidecar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_streamingsidecar() const {
+  return _internal_has_streamingsidecar();
+}
+inline void Message_AudioMessage::clear_streamingsidecar() {
+  _impl_.streamingsidecar_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_AudioMessage::streamingsidecar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.streamingSidecar)
+  return _internal_streamingsidecar();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.streamingsidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.streamingSidecar)
+}
+inline std::string* Message_AudioMessage::mutable_streamingsidecar() {
+  std::string* _s = _internal_mutable_streamingsidecar();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.streamingSidecar)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_streamingsidecar() const {
+  return _impl_.streamingsidecar_.Get();
+}
+inline void Message_AudioMessage::_internal_set_streamingsidecar(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.streamingsidecar_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_streamingsidecar() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_streamingsidecar() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.streamingSidecar)
+  if (!_internal_has_streamingsidecar()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.streamingsidecar_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.streamingsidecar_.IsDefault()) {
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) {
+  if (streamingsidecar != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.streamingsidecar_.IsDefault()) {
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.streamingSidecar)
+}
+
+// optional bytes waveform = 19;
+inline bool Message_AudioMessage::_internal_has_waveform() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_AudioMessage::has_waveform() const {
+  return _internal_has_waveform();
+}
+inline void Message_AudioMessage::clear_waveform() {
+  _impl_.waveform_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_AudioMessage::waveform() const {
+  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.waveform)
+  return _internal_waveform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_AudioMessage::set_waveform(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.waveform_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.waveform)
+}
+inline std::string* Message_AudioMessage::mutable_waveform() {
+  std::string* _s = _internal_mutable_waveform();
+  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.waveform)
+  return _s;
+}
+inline const std::string& Message_AudioMessage::_internal_waveform() const {
+  return _impl_.waveform_.Get();
+}
+inline void Message_AudioMessage::_internal_set_waveform(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.waveform_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::_internal_mutable_waveform() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.waveform_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_AudioMessage::release_waveform() {
+  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.waveform)
+  if (!_internal_has_waveform()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.waveform_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.waveform_.IsDefault()) {
+    _impl_.waveform_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_AudioMessage::set_allocated_waveform(std::string* waveform) {
+  if (waveform != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.waveform_.SetAllocated(waveform, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.waveform_.IsDefault()) {
+    _impl_.waveform_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.waveform)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ButtonsMessage_Button_ButtonText
+
+// optional string displayText = 1;
+inline bool Message_ButtonsMessage_Button_ButtonText::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage_Button_ButtonText::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void Message_ButtonsMessage_Button_ButtonText::clear_displaytext() {
+  _impl_.displaytext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ButtonsMessage_Button_ButtonText::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
+  return _internal_displaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage_Button_ButtonText::set_displaytext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
+}
+inline std::string* Message_ButtonsMessage_Button_ButtonText::mutable_displaytext() {
+  std::string* _s = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage_Button_ButtonText::_internal_displaytext() const {
+  return _impl_.displaytext_.Get();
+}
+inline void Message_ButtonsMessage_Button_ButtonText::_internal_set_displaytext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_ButtonText::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_ButtonText::release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
+  if (!_internal_has_displaytext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displaytext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage_Button_ButtonText::set_allocated_displaytext(std::string* displaytext) {
+  if (displaytext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displaytext_.IsDefault()) {
+    _impl_.displaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ButtonsMessage_Button_NativeFlowInfo
+
+// optional string name = 1;
+inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_name() const {
+  return _internal_has_name();
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::name() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage_Button_NativeFlowInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
+}
+
+// optional string paramsJson = 2;
+inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_paramsjson() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_paramsjson() const {
+  return _internal_has_paramsjson();
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_paramsjson() {
+  _impl_.paramsjson_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::paramsjson() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
+  return _internal_paramsjson();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage_Button_NativeFlowInfo::set_paramsjson(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.paramsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_paramsjson() {
+  std::string* _s = _internal_mutable_paramsjson();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_paramsjson() const {
+  return _impl_.paramsjson_.Get();
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_paramsjson(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.paramsjson_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_paramsjson() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.paramsjson_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_paramsjson() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
+  if (!_internal_has_paramsjson()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.paramsjson_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paramsjson_.IsDefault()) {
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_paramsjson(std::string* paramsjson) {
+  if (paramsjson != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paramsjson_.IsDefault()) {
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ButtonsMessage_Button
+
+// optional string buttonId = 1;
+inline bool Message_ButtonsMessage_Button::_internal_has_buttonid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage_Button::has_buttonid() const {
+  return _internal_has_buttonid();
+}
+inline void Message_ButtonsMessage_Button::clear_buttonid() {
+  _impl_.buttonid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ButtonsMessage_Button::buttonid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonId)
+  return _internal_buttonid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage_Button::set_buttonid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.buttonid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.buttonId)
+}
+inline std::string* Message_ButtonsMessage_Button::mutable_buttonid() {
+  std::string* _s = _internal_mutable_buttonid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonId)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage_Button::_internal_buttonid() const {
+  return _impl_.buttonid_.Get();
+}
+inline void Message_ButtonsMessage_Button::_internal_set_buttonid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.buttonid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button::_internal_mutable_buttonid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.buttonid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage_Button::release_buttonid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonId)
+  if (!_internal_has_buttonid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.buttonid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttonid_.IsDefault()) {
+    _impl_.buttonid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage_Button::set_allocated_buttonid(std::string* buttonid) {
+  if (buttonid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.buttonid_.SetAllocated(buttonid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttonid_.IsDefault()) {
+    _impl_.buttonid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonId)
+}
+
+// optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
+inline bool Message_ButtonsMessage_Button::_internal_has_buttontext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.buttontext_ != nullptr);
+  return value;
+}
+inline bool Message_ButtonsMessage_Button::has_buttontext() const {
+  return _internal_has_buttontext();
+}
+inline void Message_ButtonsMessage_Button::clear_buttontext() {
+  if (_impl_.buttontext_ != nullptr) _impl_.buttontext_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::_internal_buttontext() const {
+  const ::proto::Message_ButtonsMessage_Button_ButtonText* p = _impl_.buttontext_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage_Button_ButtonText&>(
+      ::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_);
+}
+inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::buttontext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonText)
+  return _internal_buttontext();
+}
+inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_buttontext(
+    ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttontext_);
+  }
+  _impl_.buttontext_ = buttontext;
+  if (buttontext) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.buttonText)
+}
+inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::release_buttontext() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_;
+  _impl_.buttontext_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::unsafe_arena_release_buttontext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonText)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_;
+  _impl_.buttontext_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::_internal_mutable_buttontext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.buttontext_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(GetArenaForAllocation());
+    _impl_.buttontext_ = p;
+  }
+  return _impl_.buttontext_;
+}
+inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::mutable_buttontext() {
+  ::proto::Message_ButtonsMessage_Button_ButtonText* _msg = _internal_mutable_buttontext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonText)
+  return _msg;
+}
+inline void Message_ButtonsMessage_Button::set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.buttontext_;
+  }
+  if (buttontext) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttontext);
+    if (message_arena != submessage_arena) {
+      buttontext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, buttontext, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.buttontext_ = buttontext;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonText)
+}
+
+// optional .proto.Message.ButtonsMessage.Button.Type type = 3;
+inline bool Message_ButtonsMessage_Button::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage_Button::has_type() const {
+  return _internal_has_type();
+}
+inline void Message_ButtonsMessage_Button::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::_internal_type() const {
+  return static_cast< ::proto::Message_ButtonsMessage_Button_Type >(_impl_.type_);
+}
+inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::type() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.type)
+  return _internal_type();
+}
+inline void Message_ButtonsMessage_Button::_internal_set_type(::proto::Message_ButtonsMessage_Button_Type value) {
+  assert(::proto::Message_ButtonsMessage_Button_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.type_ = value;
+}
+inline void Message_ButtonsMessage_Button::set_type(::proto::Message_ButtonsMessage_Button_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.type)
+}
+
+// optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
+inline bool Message_ButtonsMessage_Button::_internal_has_nativeflowinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.nativeflowinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ButtonsMessage_Button::has_nativeflowinfo() const {
+  return _internal_has_nativeflowinfo();
+}
+inline void Message_ButtonsMessage_Button::clear_nativeflowinfo() {
+  if (_impl_.nativeflowinfo_ != nullptr) _impl_.nativeflowinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::_internal_nativeflowinfo() const {
+  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* p = _impl_.nativeflowinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo&>(
+      ::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_);
+}
+inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::nativeflowinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
+  return _internal_nativeflowinfo();
+}
+inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_nativeflowinfo(
+    ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nativeflowinfo_);
+  }
+  _impl_.nativeflowinfo_ = nativeflowinfo;
+  if (nativeflowinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
+}
+inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::release_nativeflowinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_;
+  _impl_.nativeflowinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::unsafe_arena_release_nativeflowinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_;
+  _impl_.nativeflowinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::_internal_mutable_nativeflowinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.nativeflowinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(GetArenaForAllocation());
+    _impl_.nativeflowinfo_ = p;
+  }
+  return _impl_.nativeflowinfo_;
+}
+inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::mutable_nativeflowinfo() {
+  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _msg = _internal_mutable_nativeflowinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
+  return _msg;
+}
+inline void Message_ButtonsMessage_Button::set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.nativeflowinfo_;
+  }
+  if (nativeflowinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowinfo);
+    if (message_arena != submessage_arena) {
+      nativeflowinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, nativeflowinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.nativeflowinfo_ = nativeflowinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ButtonsMessage
+
+// optional string contentText = 6;
+inline bool Message_ButtonsMessage::_internal_has_contenttext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage::has_contenttext() const {
+  return _internal_has_contenttext();
+}
+inline void Message_ButtonsMessage::clear_contenttext() {
+  _impl_.contenttext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ButtonsMessage::contenttext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contentText)
+  return _internal_contenttext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage::set_contenttext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.contenttext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.contentText)
+}
+inline std::string* Message_ButtonsMessage::mutable_contenttext() {
+  std::string* _s = _internal_mutable_contenttext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contentText)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage::_internal_contenttext() const {
+  return _impl_.contenttext_.Get();
+}
+inline void Message_ButtonsMessage::_internal_set_contenttext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.contenttext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::_internal_mutable_contenttext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.contenttext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::release_contenttext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contentText)
+  if (!_internal_has_contenttext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.contenttext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.contenttext_.IsDefault()) {
+    _impl_.contenttext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage::set_allocated_contenttext(std::string* contenttext) {
+  if (contenttext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.contenttext_.SetAllocated(contenttext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.contenttext_.IsDefault()) {
+    _impl_.contenttext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contentText)
+}
+
+// optional string footerText = 7;
+inline bool Message_ButtonsMessage::_internal_has_footertext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage::has_footertext() const {
+  return _internal_has_footertext();
+}
+inline void Message_ButtonsMessage::clear_footertext() {
+  _impl_.footertext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ButtonsMessage::footertext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.footerText)
+  return _internal_footertext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsMessage::set_footertext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.footertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.footerText)
+}
+inline std::string* Message_ButtonsMessage::mutable_footertext() {
+  std::string* _s = _internal_mutable_footertext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.footerText)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage::_internal_footertext() const {
+  return _impl_.footertext_.Get();
+}
+inline void Message_ButtonsMessage::_internal_set_footertext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.footertext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::_internal_mutable_footertext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.footertext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::release_footertext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.footerText)
+  if (!_internal_has_footertext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.footertext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footertext_.IsDefault()) {
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsMessage::set_allocated_footertext(std::string* footertext) {
+  if (footertext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footertext_.IsDefault()) {
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.footerText)
+}
+
+// optional .proto.ContextInfo contextInfo = 8;
+inline bool Message_ButtonsMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ButtonsMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ButtonsMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ContextInfo& Message_ButtonsMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ButtonsMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ButtonsMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ButtonsMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ButtonsMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ButtonsMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ButtonsMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ButtonsMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contextInfo)
+}
+
+// repeated .proto.Message.ButtonsMessage.Button buttons = 9;
+inline int Message_ButtonsMessage::_internal_buttons_size() const {
+  return _impl_.buttons_.size();
+}
+inline int Message_ButtonsMessage::buttons_size() const {
+  return _internal_buttons_size();
+}
+inline void Message_ButtonsMessage::clear_buttons() {
+  _impl_.buttons_.Clear();
+}
+inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::mutable_buttons(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.buttons)
+  return _impl_.buttons_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >*
+Message_ButtonsMessage::mutable_buttons() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ButtonsMessage.buttons)
+  return &_impl_.buttons_;
+}
+inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::_internal_buttons(int index) const {
+  return _impl_.buttons_.Get(index);
+}
+inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::buttons(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.buttons)
+  return _internal_buttons(index);
+}
+inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::_internal_add_buttons() {
+  return _impl_.buttons_.Add();
+}
+inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::add_buttons() {
+  ::proto::Message_ButtonsMessage_Button* _add = _internal_add_buttons();
+  // @@protoc_insertion_point(field_add:proto.Message.ButtonsMessage.buttons)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >&
+Message_ButtonsMessage::buttons() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ButtonsMessage.buttons)
+  return _impl_.buttons_;
+}
+
+// optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
+inline bool Message_ButtonsMessage::_internal_has_headertype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ButtonsMessage::has_headertype() const {
+  return _internal_has_headertype();
+}
+inline void Message_ButtonsMessage::clear_headertype() {
+  _impl_.headertype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::_internal_headertype() const {
+  return static_cast< ::proto::Message_ButtonsMessage_HeaderType >(_impl_.headertype_);
+}
+inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::headertype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.headerType)
+  return _internal_headertype();
+}
+inline void Message_ButtonsMessage::_internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value) {
+  assert(::proto::Message_ButtonsMessage_HeaderType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.headertype_ = value;
+}
+inline void Message_ButtonsMessage::set_headertype(::proto::Message_ButtonsMessage_HeaderType value) {
+  _internal_set_headertype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.headerType)
+}
+
+// string text = 1;
+inline bool Message_ButtonsMessage::_internal_has_text() const {
+  return header_case() == kText;
+}
+inline bool Message_ButtonsMessage::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_ButtonsMessage::set_has_text() {
+  _impl_._oneof_case_[0] = kText;
+}
+inline void Message_ButtonsMessage::clear_text() {
+  if (_internal_has_text()) {
+    _impl_.header_.text_.Destroy();
+    clear_has_header();
+  }
+}
+inline const std::string& Message_ButtonsMessage::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Message_ButtonsMessage::set_text(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_text()) {
+    clear_header();
+    set_has_text();
+    _impl_.header_.text_.InitDefault();
+  }
+  _impl_.header_.text_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.text)
+}
+inline std::string* Message_ButtonsMessage::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.text)
+  return _s;
+}
+inline const std::string& Message_ButtonsMessage::_internal_text() const {
+  if (_internal_has_text()) {
+    return _impl_.header_.text_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Message_ButtonsMessage::_internal_set_text(const std::string& value) {
+  if (!_internal_has_text()) {
+    clear_header();
+    set_has_text();
+    _impl_.header_.text_.InitDefault();
+  }
+  _impl_.header_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::_internal_mutable_text() {
+  if (!_internal_has_text()) {
+    clear_header();
+    set_has_text();
+    _impl_.header_.text_.InitDefault();
+  }
+  return _impl_.header_.text_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsMessage::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.text)
+  if (_internal_has_text()) {
+    clear_has_header();
+    return _impl_.header_.text_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsMessage::set_allocated_text(std::string* text) {
+  if (has_header()) {
+    clear_header();
+  }
+  if (text != nullptr) {
+    set_has_text();
+    _impl_.header_.text_.InitAllocated(text, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.text)
+}
+
+// .proto.Message.DocumentMessage documentMessage = 2;
+inline bool Message_ButtonsMessage::_internal_has_documentmessage() const {
+  return header_case() == kDocumentMessage;
+}
+inline bool Message_ButtonsMessage::has_documentmessage() const {
+  return _internal_has_documentmessage();
+}
+inline void Message_ButtonsMessage::set_has_documentmessage() {
+  _impl_._oneof_case_[0] = kDocumentMessage;
+}
+inline void Message_ButtonsMessage::clear_documentmessage() {
+  if (_internal_has_documentmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.header_.documentmessage_;
+    }
+    clear_has_header();
+  }
+}
+inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::release_documentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_header();
+    ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.header_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::_internal_documentmessage() const {
+  return _internal_has_documentmessage()
+      ? *_impl_.header_.documentmessage_
+      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
+}
+inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::documentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.documentMessage)
+  return _internal_documentmessage();
+}
+inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::unsafe_arena_release_documentmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_header();
+    ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_;
+    _impl_.header_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsMessage::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  clear_header();
+  if (documentmessage) {
+    set_has_documentmessage();
+    _impl_.header_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.documentMessage)
+}
+inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::_internal_mutable_documentmessage() {
+  if (!_internal_has_documentmessage()) {
+    clear_header();
+    set_has_documentmessage();
+    _impl_.header_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
+  }
+  return _impl_.header_.documentmessage_;
+}
+inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::mutable_documentmessage() {
+  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.documentMessage)
+  return _msg;
+}
+
+// .proto.Message.ImageMessage imageMessage = 3;
+inline bool Message_ButtonsMessage::_internal_has_imagemessage() const {
+  return header_case() == kImageMessage;
+}
+inline bool Message_ButtonsMessage::has_imagemessage() const {
+  return _internal_has_imagemessage();
+}
+inline void Message_ButtonsMessage::set_has_imagemessage() {
+  _impl_._oneof_case_[0] = kImageMessage;
+}
+inline void Message_ButtonsMessage::clear_imagemessage() {
+  if (_internal_has_imagemessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.header_.imagemessage_;
+    }
+    clear_has_header();
+  }
+}
+inline ::proto::Message_ImageMessage* Message_ButtonsMessage::release_imagemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_header();
+    ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.header_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::_internal_imagemessage() const {
+  return _internal_has_imagemessage()
+      ? *_impl_.header_.imagemessage_
+      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::imagemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.imageMessage)
+  return _internal_imagemessage();
+}
+inline ::proto::Message_ImageMessage* Message_ButtonsMessage::unsafe_arena_release_imagemessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_header();
+    ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_;
+    _impl_.header_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsMessage::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  clear_header();
+  if (imagemessage) {
+    set_has_imagemessage();
+    _impl_.header_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.imageMessage)
+}
+inline ::proto::Message_ImageMessage* Message_ButtonsMessage::_internal_mutable_imagemessage() {
+  if (!_internal_has_imagemessage()) {
+    clear_header();
+    set_has_imagemessage();
+    _impl_.header_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
+  }
+  return _impl_.header_.imagemessage_;
+}
+inline ::proto::Message_ImageMessage* Message_ButtonsMessage::mutable_imagemessage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.imageMessage)
+  return _msg;
+}
+
+// .proto.Message.VideoMessage videoMessage = 4;
+inline bool Message_ButtonsMessage::_internal_has_videomessage() const {
+  return header_case() == kVideoMessage;
+}
+inline bool Message_ButtonsMessage::has_videomessage() const {
+  return _internal_has_videomessage();
+}
+inline void Message_ButtonsMessage::set_has_videomessage() {
+  _impl_._oneof_case_[0] = kVideoMessage;
+}
+inline void Message_ButtonsMessage::clear_videomessage() {
+  if (_internal_has_videomessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.header_.videomessage_;
+    }
+    clear_has_header();
+  }
+}
+inline ::proto::Message_VideoMessage* Message_ButtonsMessage::release_videomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_header();
+    ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.header_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::_internal_videomessage() const {
+  return _internal_has_videomessage()
+      ? *_impl_.header_.videomessage_
+      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
+}
+inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::videomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.videoMessage)
+  return _internal_videomessage();
+}
+inline ::proto::Message_VideoMessage* Message_ButtonsMessage::unsafe_arena_release_videomessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_header();
+    ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_;
+    _impl_.header_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsMessage::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  clear_header();
+  if (videomessage) {
+    set_has_videomessage();
+    _impl_.header_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.videoMessage)
+}
+inline ::proto::Message_VideoMessage* Message_ButtonsMessage::_internal_mutable_videomessage() {
+  if (!_internal_has_videomessage()) {
+    clear_header();
+    set_has_videomessage();
+    _impl_.header_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
+  }
+  return _impl_.header_.videomessage_;
+}
+inline ::proto::Message_VideoMessage* Message_ButtonsMessage::mutable_videomessage() {
+  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.videoMessage)
+  return _msg;
+}
+
+// .proto.Message.LocationMessage locationMessage = 5;
+inline bool Message_ButtonsMessage::_internal_has_locationmessage() const {
+  return header_case() == kLocationMessage;
+}
+inline bool Message_ButtonsMessage::has_locationmessage() const {
+  return _internal_has_locationmessage();
+}
+inline void Message_ButtonsMessage::set_has_locationmessage() {
+  _impl_._oneof_case_[0] = kLocationMessage;
+}
+inline void Message_ButtonsMessage::clear_locationmessage() {
+  if (_internal_has_locationmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.header_.locationmessage_;
+    }
+    clear_has_header();
+  }
+}
+inline ::proto::Message_LocationMessage* Message_ButtonsMessage::release_locationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_header();
+    ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.header_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::_internal_locationmessage() const {
+  return _internal_has_locationmessage()
+      ? *_impl_.header_.locationmessage_
+      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
+}
+inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::locationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.locationMessage)
+  return _internal_locationmessage();
+}
+inline ::proto::Message_LocationMessage* Message_ButtonsMessage::unsafe_arena_release_locationmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_header();
+    ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_;
+    _impl_.header_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsMessage::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  clear_header();
+  if (locationmessage) {
+    set_has_locationmessage();
+    _impl_.header_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.locationMessage)
+}
+inline ::proto::Message_LocationMessage* Message_ButtonsMessage::_internal_mutable_locationmessage() {
+  if (!_internal_has_locationmessage()) {
+    clear_header();
+    set_has_locationmessage();
+    _impl_.header_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
+  }
+  return _impl_.header_.locationmessage_;
+}
+inline ::proto::Message_LocationMessage* Message_ButtonsMessage::mutable_locationmessage() {
+  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.locationMessage)
+  return _msg;
+}
+
+inline bool Message_ButtonsMessage::has_header() const {
+  return header_case() != HEADER_NOT_SET;
+}
+inline void Message_ButtonsMessage::clear_has_header() {
+  _impl_._oneof_case_[0] = HEADER_NOT_SET;
+}
+inline Message_ButtonsMessage::HeaderCase Message_ButtonsMessage::header_case() const {
+  return Message_ButtonsMessage::HeaderCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_ButtonsResponseMessage
+
+// optional string selectedButtonId = 1;
+inline bool Message_ButtonsResponseMessage::_internal_has_selectedbuttonid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ButtonsResponseMessage::has_selectedbuttonid() const {
+  return _internal_has_selectedbuttonid();
+}
+inline void Message_ButtonsResponseMessage::clear_selectedbuttonid() {
+  _impl_.selectedbuttonid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ButtonsResponseMessage::selectedbuttonid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedButtonId)
+  return _internal_selectedbuttonid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ButtonsResponseMessage::set_selectedbuttonid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.selectedbuttonid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedButtonId)
+}
+inline std::string* Message_ButtonsResponseMessage::mutable_selectedbuttonid() {
+  std::string* _s = _internal_mutable_selectedbuttonid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedButtonId)
+  return _s;
+}
+inline const std::string& Message_ButtonsResponseMessage::_internal_selectedbuttonid() const {
+  return _impl_.selectedbuttonid_.Get();
+}
+inline void Message_ButtonsResponseMessage::_internal_set_selectedbuttonid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.selectedbuttonid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selectedbuttonid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.selectedbuttonid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsResponseMessage::release_selectedbuttonid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedButtonId)
+  if (!_internal_has_selectedbuttonid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.selectedbuttonid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedbuttonid_.IsDefault()) {
+    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ButtonsResponseMessage::set_allocated_selectedbuttonid(std::string* selectedbuttonid) {
+  if (selectedbuttonid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.selectedbuttonid_.SetAllocated(selectedbuttonid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedbuttonid_.IsDefault()) {
+    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedButtonId)
+}
+
+// optional .proto.ContextInfo contextInfo = 3;
+inline bool Message_ButtonsResponseMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ButtonsResponseMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ButtonsResponseMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ButtonsResponseMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ButtonsResponseMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ButtonsResponseMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ButtonsResponseMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ButtonsResponseMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ButtonsResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo)
+}
+
+// optional .proto.Message.ButtonsResponseMessage.Type type = 4;
+inline bool Message_ButtonsResponseMessage::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ButtonsResponseMessage::has_type() const {
+  return _internal_has_type();
+}
+inline void Message_ButtonsResponseMessage::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::_internal_type() const {
+  return static_cast< ::proto::Message_ButtonsResponseMessage_Type >(_impl_.type_);
+}
+inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::type() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.type)
+  return _internal_type();
+}
+inline void Message_ButtonsResponseMessage::_internal_set_type(::proto::Message_ButtonsResponseMessage_Type value) {
+  assert(::proto::Message_ButtonsResponseMessage_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.type_ = value;
+}
+inline void Message_ButtonsResponseMessage::set_type(::proto::Message_ButtonsResponseMessage_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.type)
+}
+
+// string selectedDisplayText = 2;
+inline bool Message_ButtonsResponseMessage::_internal_has_selecteddisplaytext() const {
+  return response_case() == kSelectedDisplayText;
+}
+inline bool Message_ButtonsResponseMessage::has_selecteddisplaytext() const {
+  return _internal_has_selecteddisplaytext();
+}
+inline void Message_ButtonsResponseMessage::set_has_selecteddisplaytext() {
+  _impl_._oneof_case_[0] = kSelectedDisplayText;
+}
+inline void Message_ButtonsResponseMessage::clear_selecteddisplaytext() {
+  if (_internal_has_selecteddisplaytext()) {
+    _impl_.response_.selecteddisplaytext_.Destroy();
+    clear_has_response();
+  }
+}
+inline const std::string& Message_ButtonsResponseMessage::selecteddisplaytext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedDisplayText)
+  return _internal_selecteddisplaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Message_ButtonsResponseMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_selecteddisplaytext()) {
+    clear_response();
+    set_has_selecteddisplaytext();
+    _impl_.response_.selecteddisplaytext_.InitDefault();
+  }
+  _impl_.response_.selecteddisplaytext_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedDisplayText)
+}
+inline std::string* Message_ButtonsResponseMessage::mutable_selecteddisplaytext() {
+  std::string* _s = _internal_mutable_selecteddisplaytext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedDisplayText)
+  return _s;
+}
+inline const std::string& Message_ButtonsResponseMessage::_internal_selecteddisplaytext() const {
+  if (_internal_has_selecteddisplaytext()) {
+    return _impl_.response_.selecteddisplaytext_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Message_ButtonsResponseMessage::_internal_set_selecteddisplaytext(const std::string& value) {
+  if (!_internal_has_selecteddisplaytext()) {
+    clear_response();
+    set_has_selecteddisplaytext();
+    _impl_.response_.selecteddisplaytext_.InitDefault();
+  }
+  _impl_.response_.selecteddisplaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selecteddisplaytext() {
+  if (!_internal_has_selecteddisplaytext()) {
+    clear_response();
+    set_has_selecteddisplaytext();
+    _impl_.response_.selecteddisplaytext_.InitDefault();
+  }
+  return _impl_.response_.selecteddisplaytext_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Message_ButtonsResponseMessage::release_selecteddisplaytext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedDisplayText)
+  if (_internal_has_selecteddisplaytext()) {
+    clear_has_response();
+    return _impl_.response_.selecteddisplaytext_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_ButtonsResponseMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) {
+  if (has_response()) {
+    clear_response();
+  }
+  if (selecteddisplaytext != nullptr) {
+    set_has_selecteddisplaytext();
+    _impl_.response_.selecteddisplaytext_.InitAllocated(selecteddisplaytext, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedDisplayText)
+}
+
+inline bool Message_ButtonsResponseMessage::has_response() const {
+  return response_case() != RESPONSE_NOT_SET;
+}
+inline void Message_ButtonsResponseMessage::clear_has_response() {
+  _impl_._oneof_case_[0] = RESPONSE_NOT_SET;
+}
+inline Message_ButtonsResponseMessage::ResponseCase Message_ButtonsResponseMessage::response_case() const {
+  return Message_ButtonsResponseMessage::ResponseCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_Call
+
+// optional bytes callKey = 1;
+inline bool Message_Call::_internal_has_callkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_Call::has_callkey() const {
+  return _internal_has_callkey();
+}
+inline void Message_Call::clear_callkey() {
+  _impl_.callkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_Call::callkey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Call.callKey)
+  return _internal_callkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_Call::set_callkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.callkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.Call.callKey)
+}
+inline std::string* Message_Call::mutable_callkey() {
+  std::string* _s = _internal_mutable_callkey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.Call.callKey)
+  return _s;
+}
+inline const std::string& Message_Call::_internal_callkey() const {
+  return _impl_.callkey_.Get();
+}
+inline void Message_Call::_internal_set_callkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.callkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_Call::_internal_mutable_callkey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.callkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_Call::release_callkey() {
+  // @@protoc_insertion_point(field_release:proto.Message.Call.callKey)
+  if (!_internal_has_callkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.callkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.callkey_.IsDefault()) {
+    _impl_.callkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_Call::set_allocated_callkey(std::string* callkey) {
+  if (callkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.callkey_.SetAllocated(callkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.callkey_.IsDefault()) {
+    _impl_.callkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.callKey)
+}
+
+// optional string conversionSource = 2;
+inline bool Message_Call::_internal_has_conversionsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_Call::has_conversionsource() const {
+  return _internal_has_conversionsource();
+}
+inline void Message_Call::clear_conversionsource() {
+  _impl_.conversionsource_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_Call::conversionsource() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionSource)
+  return _internal_conversionsource();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_Call::set_conversionsource(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.conversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionSource)
+}
+inline std::string* Message_Call::mutable_conversionsource() {
+  std::string* _s = _internal_mutable_conversionsource();
+  // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionSource)
+  return _s;
+}
+inline const std::string& Message_Call::_internal_conversionsource() const {
+  return _impl_.conversionsource_.Get();
+}
+inline void Message_Call::_internal_set_conversionsource(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.conversionsource_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_Call::_internal_mutable_conversionsource() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.conversionsource_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_Call::release_conversionsource() {
+  // @@protoc_insertion_point(field_release:proto.Message.Call.conversionSource)
+  if (!_internal_has_conversionsource()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.conversionsource_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversionsource_.IsDefault()) {
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_Call::set_allocated_conversionsource(std::string* conversionsource) {
+  if (conversionsource != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversionsource_.IsDefault()) {
+    _impl_.conversionsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionSource)
+}
+
+// optional bytes conversionData = 3;
+inline bool Message_Call::_internal_has_conversiondata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_Call::has_conversiondata() const {
+  return _internal_has_conversiondata();
+}
+inline void Message_Call::clear_conversiondata() {
+  _impl_.conversiondata_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_Call::conversiondata() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionData)
+  return _internal_conversiondata();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_Call::set_conversiondata(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.conversiondata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionData)
+}
+inline std::string* Message_Call::mutable_conversiondata() {
+  std::string* _s = _internal_mutable_conversiondata();
+  // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionData)
+  return _s;
+}
+inline const std::string& Message_Call::_internal_conversiondata() const {
+  return _impl_.conversiondata_.Get();
+}
+inline void Message_Call::_internal_set_conversiondata(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.conversiondata_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_Call::_internal_mutable_conversiondata() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.conversiondata_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_Call::release_conversiondata() {
+  // @@protoc_insertion_point(field_release:proto.Message.Call.conversionData)
+  if (!_internal_has_conversiondata()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.conversiondata_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversiondata_.IsDefault()) {
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_Call::set_allocated_conversiondata(std::string* conversiondata) {
+  if (conversiondata != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversiondata_.IsDefault()) {
+    _impl_.conversiondata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionData)
+}
+
+// optional uint32 conversionDelaySeconds = 4;
+inline bool Message_Call::_internal_has_conversiondelayseconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_Call::has_conversiondelayseconds() const {
+  return _internal_has_conversiondelayseconds();
+}
+inline void Message_Call::clear_conversiondelayseconds() {
+  _impl_.conversiondelayseconds_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t Message_Call::_internal_conversiondelayseconds() const {
+  return _impl_.conversiondelayseconds_;
+}
+inline uint32_t Message_Call::conversiondelayseconds() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionDelaySeconds)
+  return _internal_conversiondelayseconds();
+}
+inline void Message_Call::_internal_set_conversiondelayseconds(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.conversiondelayseconds_ = value;
+}
+inline void Message_Call::set_conversiondelayseconds(uint32_t value) {
+  _internal_set_conversiondelayseconds(value);
+  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionDelaySeconds)
+}
+
+// -------------------------------------------------------------------
+
+// Message_CancelPaymentRequestMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool Message_CancelPaymentRequestMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Message_CancelPaymentRequestMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void Message_CancelPaymentRequestMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.Message.CancelPaymentRequestMessage.key)
+  return _internal_key();
+}
+inline void Message_CancelPaymentRequestMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.CancelPaymentRequestMessage.key)
+}
+inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Message.CancelPaymentRequestMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Message.CancelPaymentRequestMessage.key)
+  return _msg;
+}
+inline void Message_CancelPaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.CancelPaymentRequestMessage.key)
+}
+
+// -------------------------------------------------------------------
+
+// Message_Chat
+
+// optional string displayName = 1;
+inline bool Message_Chat::_internal_has_displayname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_Chat::has_displayname() const {
+  return _internal_has_displayname();
+}
+inline void Message_Chat::clear_displayname() {
+  _impl_.displayname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_Chat::displayname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Chat.displayName)
+  return _internal_displayname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_Chat::set_displayname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.Chat.displayName)
+}
+inline std::string* Message_Chat::mutable_displayname() {
+  std::string* _s = _internal_mutable_displayname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.Chat.displayName)
+  return _s;
+}
+inline const std::string& Message_Chat::_internal_displayname() const {
+  return _impl_.displayname_.Get();
+}
+inline void Message_Chat::_internal_set_displayname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displayname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_Chat::_internal_mutable_displayname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displayname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_Chat::release_displayname() {
+  // @@protoc_insertion_point(field_release:proto.Message.Chat.displayName)
+  if (!_internal_has_displayname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displayname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_Chat::set_allocated_displayname(std::string* displayname) {
+  if (displayname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.displayName)
+}
+
+// optional string id = 2;
+inline bool Message_Chat::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_Chat::has_id() const {
+  return _internal_has_id();
+}
+inline void Message_Chat::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_Chat::id() const {
+  // @@protoc_insertion_point(field_get:proto.Message.Chat.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_Chat::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.Chat.id)
+}
+inline std::string* Message_Chat::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.Message.Chat.id)
+  return _s;
+}
+inline const std::string& Message_Chat::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void Message_Chat::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_Chat::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_Chat::release_id() {
+  // @@protoc_insertion_point(field_release:proto.Message.Chat.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_Chat::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.id)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ContactMessage
+
+// optional string displayName = 1;
+inline bool Message_ContactMessage::_internal_has_displayname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ContactMessage::has_displayname() const {
+  return _internal_has_displayname();
+}
+inline void Message_ContactMessage::clear_displayname() {
+  _impl_.displayname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ContactMessage::displayname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.displayName)
+  return _internal_displayname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ContactMessage::set_displayname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.displayName)
+}
+inline std::string* Message_ContactMessage::mutable_displayname() {
+  std::string* _s = _internal_mutable_displayname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.displayName)
+  return _s;
+}
+inline const std::string& Message_ContactMessage::_internal_displayname() const {
+  return _impl_.displayname_.Get();
+}
+inline void Message_ContactMessage::_internal_set_displayname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displayname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ContactMessage::_internal_mutable_displayname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displayname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ContactMessage::release_displayname() {
+  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.displayName)
+  if (!_internal_has_displayname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displayname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ContactMessage::set_allocated_displayname(std::string* displayname) {
+  if (displayname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.displayName)
+}
+
+// optional string vcard = 16;
+inline bool Message_ContactMessage::_internal_has_vcard() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ContactMessage::has_vcard() const {
+  return _internal_has_vcard();
+}
+inline void Message_ContactMessage::clear_vcard() {
+  _impl_.vcard_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ContactMessage::vcard() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.vcard)
+  return _internal_vcard();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ContactMessage::set_vcard(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.vcard_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.vcard)
+}
+inline std::string* Message_ContactMessage::mutable_vcard() {
+  std::string* _s = _internal_mutable_vcard();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.vcard)
+  return _s;
+}
+inline const std::string& Message_ContactMessage::_internal_vcard() const {
+  return _impl_.vcard_.Get();
+}
+inline void Message_ContactMessage::_internal_set_vcard(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.vcard_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ContactMessage::_internal_mutable_vcard() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.vcard_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ContactMessage::release_vcard() {
+  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.vcard)
+  if (!_internal_has_vcard()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.vcard_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.vcard_.IsDefault()) {
+    _impl_.vcard_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ContactMessage::set_allocated_vcard(std::string* vcard) {
+  if (vcard != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.vcard_.SetAllocated(vcard, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.vcard_.IsDefault()) {
+    _impl_.vcard_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.vcard)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_ContactMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ContactMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ContactMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ContextInfo& Message_ContactMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ContactMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ContactMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ContactMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ContactMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ContactMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ContactMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ContactMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ContactsArrayMessage
+
+// optional string displayName = 1;
+inline bool Message_ContactsArrayMessage::_internal_has_displayname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ContactsArrayMessage::has_displayname() const {
+  return _internal_has_displayname();
+}
+inline void Message_ContactsArrayMessage::clear_displayname() {
+  _impl_.displayname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ContactsArrayMessage::displayname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.displayName)
+  return _internal_displayname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ContactsArrayMessage::set_displayname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ContactsArrayMessage.displayName)
+}
+inline std::string* Message_ContactsArrayMessage::mutable_displayname() {
+  std::string* _s = _internal_mutable_displayname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.displayName)
+  return _s;
+}
+inline const std::string& Message_ContactsArrayMessage::_internal_displayname() const {
+  return _impl_.displayname_.Get();
+}
+inline void Message_ContactsArrayMessage::_internal_set_displayname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.displayname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ContactsArrayMessage::_internal_mutable_displayname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.displayname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ContactsArrayMessage::release_displayname() {
+  // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.displayName)
+  if (!_internal_has_displayname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.displayname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ContactsArrayMessage::set_allocated_displayname(std::string* displayname) {
+  if (displayname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.displayname_.IsDefault()) {
+    _impl_.displayname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.displayName)
+}
+
+// repeated .proto.Message.ContactMessage contacts = 2;
+inline int Message_ContactsArrayMessage::_internal_contacts_size() const {
+  return _impl_.contacts_.size();
+}
+inline int Message_ContactsArrayMessage::contacts_size() const {
+  return _internal_contacts_size();
+}
+inline void Message_ContactsArrayMessage::clear_contacts() {
+  _impl_.contacts_.Clear();
+}
+inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::mutable_contacts(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contacts)
+  return _impl_.contacts_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >*
+Message_ContactsArrayMessage::mutable_contacts() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ContactsArrayMessage.contacts)
+  return &_impl_.contacts_;
+}
+inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::_internal_contacts(int index) const {
+  return _impl_.contacts_.Get(index);
+}
+inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::contacts(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contacts)
+  return _internal_contacts(index);
+}
+inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::_internal_add_contacts() {
+  return _impl_.contacts_.Add();
+}
+inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::add_contacts() {
+  ::proto::Message_ContactMessage* _add = _internal_add_contacts();
+  // @@protoc_insertion_point(field_add:proto.Message.ContactsArrayMessage.contacts)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >&
+Message_ContactsArrayMessage::contacts() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ContactsArrayMessage.contacts)
+  return _impl_.contacts_;
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_ContactsArrayMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ContactsArrayMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ContactsArrayMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::ContextInfo& Message_ContactsArrayMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ContactsArrayMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ContactsArrayMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactsArrayMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ContactsArrayMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ContactsArrayMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ContactsArrayMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ContactsArrayMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ContactsArrayMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_DeclinePaymentRequestMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool Message_DeclinePaymentRequestMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Message_DeclinePaymentRequestMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void Message_DeclinePaymentRequestMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DeclinePaymentRequestMessage.key)
+  return _internal_key();
+}
+inline void Message_DeclinePaymentRequestMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeclinePaymentRequestMessage.key)
+}
+inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Message.DeclinePaymentRequestMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DeclinePaymentRequestMessage.key)
+  return _msg;
+}
+inline void Message_DeclinePaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeclinePaymentRequestMessage.key)
+}
+
+// -------------------------------------------------------------------
+
+// Message_DeviceSentMessage
+
+// optional string destinationJid = 1;
+inline bool Message_DeviceSentMessage::_internal_has_destinationjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_DeviceSentMessage::has_destinationjid() const {
+  return _internal_has_destinationjid();
+}
+inline void Message_DeviceSentMessage::clear_destinationjid() {
+  _impl_.destinationjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_DeviceSentMessage::destinationjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.destinationJid)
+  return _internal_destinationjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DeviceSentMessage::set_destinationjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.destinationjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.destinationJid)
+}
+inline std::string* Message_DeviceSentMessage::mutable_destinationjid() {
+  std::string* _s = _internal_mutable_destinationjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.destinationJid)
+  return _s;
+}
+inline const std::string& Message_DeviceSentMessage::_internal_destinationjid() const {
+  return _impl_.destinationjid_.Get();
+}
+inline void Message_DeviceSentMessage::_internal_set_destinationjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.destinationjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DeviceSentMessage::_internal_mutable_destinationjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.destinationjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DeviceSentMessage::release_destinationjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.destinationJid)
+  if (!_internal_has_destinationjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.destinationjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.destinationjid_.IsDefault()) {
+    _impl_.destinationjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DeviceSentMessage::set_allocated_destinationjid(std::string* destinationjid) {
+  if (destinationjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.destinationjid_.SetAllocated(destinationjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.destinationjid_.IsDefault()) {
+    _impl_.destinationjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.destinationJid)
+}
+
+// optional .proto.Message message = 2;
+inline bool Message_DeviceSentMessage::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
+  return value;
+}
+inline bool Message_DeviceSentMessage::has_message() const {
+  return _internal_has_message();
+}
+inline void Message_DeviceSentMessage::clear_message() {
+  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message& Message_DeviceSentMessage::_internal_message() const {
+  const ::proto::Message* p = _impl_.message_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& Message_DeviceSentMessage::message() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.message)
+  return _internal_message();
+}
+inline void Message_DeviceSentMessage::unsafe_arena_set_allocated_message(
+    ::proto::Message* message) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
+  }
+  _impl_.message_ = message;
+  if (message) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeviceSentMessage.message)
+}
+inline ::proto::Message* Message_DeviceSentMessage::release_message() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* Message_DeviceSentMessage::unsafe_arena_release_message() {
+  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.message)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* Message_DeviceSentMessage::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.message_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.message_ = p;
+  }
+  return _impl_.message_;
+}
+inline ::proto::Message* Message_DeviceSentMessage::mutable_message() {
+  ::proto::Message* _msg = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.message)
+  return _msg;
+}
+inline void Message_DeviceSentMessage::set_allocated_message(::proto::Message* message) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.message_;
+  }
+  if (message) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
+    if (message_arena != submessage_arena) {
+      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, message, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.message_ = message;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.message)
+}
+
+// optional string phash = 3;
+inline bool Message_DeviceSentMessage::_internal_has_phash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_DeviceSentMessage::has_phash() const {
+  return _internal_has_phash();
+}
+inline void Message_DeviceSentMessage::clear_phash() {
+  _impl_.phash_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_DeviceSentMessage::phash() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.phash)
+  return _internal_phash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DeviceSentMessage::set_phash(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.phash_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.phash)
+}
+inline std::string* Message_DeviceSentMessage::mutable_phash() {
+  std::string* _s = _internal_mutable_phash();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.phash)
+  return _s;
+}
+inline const std::string& Message_DeviceSentMessage::_internal_phash() const {
+  return _impl_.phash_.Get();
+}
+inline void Message_DeviceSentMessage::_internal_set_phash(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.phash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DeviceSentMessage::_internal_mutable_phash() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.phash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DeviceSentMessage::release_phash() {
+  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.phash)
+  if (!_internal_has_phash()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.phash_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phash_.IsDefault()) {
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DeviceSentMessage::set_allocated_phash(std::string* phash) {
+  if (phash != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.phash_.SetAllocated(phash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.phash_.IsDefault()) {
+    _impl_.phash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.phash)
+}
+
+// -------------------------------------------------------------------
+
+// Message_DocumentMessage
+
+// optional string url = 1;
+inline bool Message_DocumentMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_DocumentMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_DocumentMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.url)
+}
+inline std::string* Message_DocumentMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.url)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.url)
+}
+
+// optional string mimetype = 2;
+inline bool Message_DocumentMessage::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void Message_DocumentMessage::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_DocumentMessage::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mimetype)
+}
+inline std::string* Message_DocumentMessage::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mimetype)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mimetype)
+}
+
+// optional string title = 3;
+inline bool Message_DocumentMessage::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_DocumentMessage::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_DocumentMessage::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.title)
+}
+inline std::string* Message_DocumentMessage::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.title)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.title)
+}
+
+// optional bytes fileSha256 = 4;
+inline bool Message_DocumentMessage::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_DocumentMessage::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_DocumentMessage::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileSha256)
+}
+inline std::string* Message_DocumentMessage::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileSha256)
+}
+
+// optional uint64 fileLength = 5;
+inline bool Message_DocumentMessage::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_DocumentMessage::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline uint64_t Message_DocumentMessage::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_DocumentMessage::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileLength)
+  return _internal_filelength();
+}
+inline void Message_DocumentMessage::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.filelength_ = value;
+}
+inline void Message_DocumentMessage::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileLength)
+}
+
+// optional uint32 pageCount = 6;
+inline bool Message_DocumentMessage::_internal_has_pagecount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_pagecount() const {
+  return _internal_has_pagecount();
+}
+inline void Message_DocumentMessage::clear_pagecount() {
+  _impl_.pagecount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline uint32_t Message_DocumentMessage::_internal_pagecount() const {
+  return _impl_.pagecount_;
+}
+inline uint32_t Message_DocumentMessage::pagecount() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.pageCount)
+  return _internal_pagecount();
+}
+inline void Message_DocumentMessage::_internal_set_pagecount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.pagecount_ = value;
+}
+inline void Message_DocumentMessage::set_pagecount(uint32_t value) {
+  _internal_set_pagecount(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.pageCount)
+}
+
+// optional bytes mediaKey = 7;
+inline bool Message_DocumentMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_DocumentMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_DocumentMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKey)
+}
+inline std::string* Message_DocumentMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mediaKey)
+}
+
+// optional string fileName = 8;
+inline bool Message_DocumentMessage::_internal_has_filename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_filename() const {
+  return _internal_has_filename();
+}
+inline void Message_DocumentMessage::clear_filename() {
+  _impl_.filename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_DocumentMessage::filename() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileName)
+  return _internal_filename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_filename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileName)
+}
+inline std::string* Message_DocumentMessage::mutable_filename() {
+  std::string* _s = _internal_mutable_filename();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileName)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_filename() const {
+  return _impl_.filename_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_filename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.filename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_filename() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.filename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_filename() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileName)
+  if (!_internal_has_filename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.filename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filename_.IsDefault()) {
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_filename(std::string* filename) {
+  if (filename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filename_.IsDefault()) {
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileName)
+}
+
+// optional bytes fileEncSha256 = 9;
+inline bool Message_DocumentMessage::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_DocumentMessage::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_DocumentMessage::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileEncSha256)
+}
+inline std::string* Message_DocumentMessage::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileEncSha256)
+}
+
+// optional string directPath = 10;
+inline bool Message_DocumentMessage::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_DocumentMessage::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_DocumentMessage::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.directPath)
+}
+inline std::string* Message_DocumentMessage::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.directPath)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.directPath)
+}
+
+// optional int64 mediaKeyTimestamp = 11;
+inline bool Message_DocumentMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_DocumentMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline int64_t Message_DocumentMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_DocumentMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_DocumentMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_DocumentMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKeyTimestamp)
+}
+
+// optional bool contactVcard = 12;
+inline bool Message_DocumentMessage::_internal_has_contactvcard() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_contactvcard() const {
+  return _internal_has_contactvcard();
+}
+inline void Message_DocumentMessage::clear_contactvcard() {
+  _impl_.contactvcard_ = false;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline bool Message_DocumentMessage::_internal_contactvcard() const {
+  return _impl_.contactvcard_;
+}
+inline bool Message_DocumentMessage::contactvcard() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contactVcard)
+  return _internal_contactvcard();
+}
+inline void Message_DocumentMessage::_internal_set_contactvcard(bool value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.contactvcard_ = value;
+}
+inline void Message_DocumentMessage::set_contactvcard(bool value) {
+  _internal_set_contactvcard(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.contactVcard)
+}
+
+// optional string thumbnailDirectPath = 13;
+inline bool Message_DocumentMessage::_internal_has_thumbnaildirectpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_thumbnaildirectpath() const {
+  return _internal_has_thumbnaildirectpath();
+}
+inline void Message_DocumentMessage::clear_thumbnaildirectpath() {
+  _impl_.thumbnaildirectpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& Message_DocumentMessage::thumbnaildirectpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailDirectPath)
+  return _internal_thumbnaildirectpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailDirectPath)
+}
+inline std::string* Message_DocumentMessage::mutable_thumbnaildirectpath() {
+  std::string* _s = _internal_mutable_thumbnaildirectpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailDirectPath)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_thumbnaildirectpath() const {
+  return _impl_.thumbnaildirectpath_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_thumbnaildirectpath() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_thumbnaildirectpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailDirectPath)
+  if (!_internal_has_thumbnaildirectpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.thumbnaildirectpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
+  if (thumbnaildirectpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailDirectPath)
+}
+
+// optional bytes thumbnailSha256 = 14;
+inline bool Message_DocumentMessage::_internal_has_thumbnailsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_thumbnailsha256() const {
+  return _internal_has_thumbnailsha256();
+}
+inline void Message_DocumentMessage::clear_thumbnailsha256() {
+  _impl_.thumbnailsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& Message_DocumentMessage::thumbnailsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailSha256)
+  return _internal_thumbnailsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailSha256)
+}
+inline std::string* Message_DocumentMessage::mutable_thumbnailsha256() {
+  std::string* _s = _internal_mutable_thumbnailsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailSha256)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_thumbnailsha256() const {
+  return _impl_.thumbnailsha256_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_thumbnailsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailsha256() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_thumbnailsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailSha256)
+  if (!_internal_has_thumbnailsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.thumbnailsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
+  if (thumbnailsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailSha256)
+}
+
+// optional bytes thumbnailEncSha256 = 15;
+inline bool Message_DocumentMessage::_internal_has_thumbnailencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_thumbnailencsha256() const {
+  return _internal_has_thumbnailencsha256();
+}
+inline void Message_DocumentMessage::clear_thumbnailencsha256() {
+  _impl_.thumbnailencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& Message_DocumentMessage::thumbnailencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailEncSha256)
+  return _internal_thumbnailencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailEncSha256)
+}
+inline std::string* Message_DocumentMessage::mutable_thumbnailencsha256() {
+  std::string* _s = _internal_mutable_thumbnailencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailEncSha256)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_thumbnailencsha256() const {
+  return _impl_.thumbnailencsha256_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_thumbnailencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailencsha256() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_thumbnailencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailEncSha256)
+  if (!_internal_has_thumbnailencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.thumbnailencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
+  if (thumbnailencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailEncSha256)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_DocumentMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_DocumentMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& Message_DocumentMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.jpegThumbnail)
+}
+inline std::string* Message_DocumentMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_DocumentMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_DocumentMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_DocumentMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::ContextInfo& Message_DocumentMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_DocumentMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_DocumentMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DocumentMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_DocumentMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_DocumentMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_DocumentMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_DocumentMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.contextInfo)
+  return _msg;
+}
+inline void Message_DocumentMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.contextInfo)
+}
+
+// optional uint32 thumbnailHeight = 18;
+inline bool Message_DocumentMessage::_internal_has_thumbnailheight() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_thumbnailheight() const {
+  return _internal_has_thumbnailheight();
+}
+inline void Message_DocumentMessage::clear_thumbnailheight() {
+  _impl_.thumbnailheight_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline uint32_t Message_DocumentMessage::_internal_thumbnailheight() const {
+  return _impl_.thumbnailheight_;
+}
+inline uint32_t Message_DocumentMessage::thumbnailheight() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailHeight)
+  return _internal_thumbnailheight();
+}
+inline void Message_DocumentMessage::_internal_set_thumbnailheight(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.thumbnailheight_ = value;
+}
+inline void Message_DocumentMessage::set_thumbnailheight(uint32_t value) {
+  _internal_set_thumbnailheight(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailHeight)
+}
+
+// optional uint32 thumbnailWidth = 19;
+inline bool Message_DocumentMessage::_internal_has_thumbnailwidth() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_thumbnailwidth() const {
+  return _internal_has_thumbnailwidth();
+}
+inline void Message_DocumentMessage::clear_thumbnailwidth() {
+  _impl_.thumbnailwidth_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline uint32_t Message_DocumentMessage::_internal_thumbnailwidth() const {
+  return _impl_.thumbnailwidth_;
+}
+inline uint32_t Message_DocumentMessage::thumbnailwidth() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailWidth)
+  return _internal_thumbnailwidth();
+}
+inline void Message_DocumentMessage::_internal_set_thumbnailwidth(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.thumbnailwidth_ = value;
+}
+inline void Message_DocumentMessage::set_thumbnailwidth(uint32_t value) {
+  _internal_set_thumbnailwidth(value);
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailWidth)
+}
+
+// optional string caption = 20;
+inline bool Message_DocumentMessage::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool Message_DocumentMessage::has_caption() const {
+  return _internal_has_caption();
+}
+inline void Message_DocumentMessage::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const std::string& Message_DocumentMessage::caption() const {
+  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_DocumentMessage::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00001000u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.caption)
+}
+inline std::string* Message_DocumentMessage::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.caption)
+  return _s;
+}
+inline const std::string& Message_DocumentMessage::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void Message_DocumentMessage::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_DocumentMessage::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_DocumentMessage::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.caption)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ExtendedTextMessage
+
+// optional string text = 1;
+inline bool Message_ExtendedTextMessage::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_ExtendedTextMessage::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ExtendedTextMessage::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.text)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.text)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.text)
+}
+
+// optional string matchedText = 2;
+inline bool Message_ExtendedTextMessage::_internal_has_matchedtext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_matchedtext() const {
+  return _internal_has_matchedtext();
+}
+inline void Message_ExtendedTextMessage::clear_matchedtext() {
+  _impl_.matchedtext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ExtendedTextMessage::matchedtext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.matchedText)
+  return _internal_matchedtext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_matchedtext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.matchedtext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.matchedText)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_matchedtext() {
+  std::string* _s = _internal_mutable_matchedtext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.matchedText)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_matchedtext() const {
+  return _impl_.matchedtext_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_matchedtext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.matchedtext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_matchedtext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.matchedtext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_matchedtext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.matchedText)
+  if (!_internal_has_matchedtext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.matchedtext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.matchedtext_.IsDefault()) {
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_matchedtext(std::string* matchedtext) {
+  if (matchedtext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.matchedtext_.IsDefault()) {
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.matchedText)
+}
+
+// optional string canonicalUrl = 4;
+inline bool Message_ExtendedTextMessage::_internal_has_canonicalurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_canonicalurl() const {
+  return _internal_has_canonicalurl();
+}
+inline void Message_ExtendedTextMessage::clear_canonicalurl() {
+  _impl_.canonicalurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ExtendedTextMessage::canonicalurl() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.canonicalUrl)
+  return _internal_canonicalurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_canonicalurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.canonicalurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.canonicalUrl)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_canonicalurl() {
+  std::string* _s = _internal_mutable_canonicalurl();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.canonicalUrl)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_canonicalurl() const {
+  return _impl_.canonicalurl_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_canonicalurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.canonicalurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_canonicalurl() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.canonicalurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_canonicalurl() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.canonicalUrl)
+  if (!_internal_has_canonicalurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.canonicalurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.canonicalurl_.IsDefault()) {
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_canonicalurl(std::string* canonicalurl) {
+  if (canonicalurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.canonicalurl_.IsDefault()) {
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.canonicalUrl)
+}
+
+// optional string description = 5;
+inline bool Message_ExtendedTextMessage::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ExtendedTextMessage::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_ExtendedTextMessage::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.description)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.description)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.description)
+}
+
+// optional string title = 6;
+inline bool Message_ExtendedTextMessage::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ExtendedTextMessage::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_ExtendedTextMessage::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.title)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.title)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.title)
+}
+
+// optional fixed32 textArgb = 7;
+inline bool Message_ExtendedTextMessage::_internal_has_textargb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_textargb() const {
+  return _internal_has_textargb();
+}
+inline void Message_ExtendedTextMessage::clear_textargb() {
+  _impl_.textargb_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline uint32_t Message_ExtendedTextMessage::_internal_textargb() const {
+  return _impl_.textargb_;
+}
+inline uint32_t Message_ExtendedTextMessage::textargb() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.textArgb)
+  return _internal_textargb();
+}
+inline void Message_ExtendedTextMessage::_internal_set_textargb(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.textargb_ = value;
+}
+inline void Message_ExtendedTextMessage::set_textargb(uint32_t value) {
+  _internal_set_textargb(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.textArgb)
+}
+
+// optional fixed32 backgroundArgb = 8;
+inline bool Message_ExtendedTextMessage::_internal_has_backgroundargb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_backgroundargb() const {
+  return _internal_has_backgroundargb();
+}
+inline void Message_ExtendedTextMessage::clear_backgroundargb() {
+  _impl_.backgroundargb_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline uint32_t Message_ExtendedTextMessage::_internal_backgroundargb() const {
+  return _impl_.backgroundargb_;
+}
+inline uint32_t Message_ExtendedTextMessage::backgroundargb() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.backgroundArgb)
+  return _internal_backgroundargb();
+}
+inline void Message_ExtendedTextMessage::_internal_set_backgroundargb(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.backgroundargb_ = value;
+}
+inline void Message_ExtendedTextMessage::set_backgroundargb(uint32_t value) {
+  _internal_set_backgroundargb(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.backgroundArgb)
+}
+
+// optional .proto.Message.ExtendedTextMessage.FontType font = 9;
+inline bool Message_ExtendedTextMessage::_internal_has_font() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_font() const {
+  return _internal_has_font();
+}
+inline void Message_ExtendedTextMessage::clear_font() {
+  _impl_.font_ = 0;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::_internal_font() const {
+  return static_cast< ::proto::Message_ExtendedTextMessage_FontType >(_impl_.font_);
+}
+inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::font() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.font)
+  return _internal_font();
+}
+inline void Message_ExtendedTextMessage::_internal_set_font(::proto::Message_ExtendedTextMessage_FontType value) {
+  assert(::proto::Message_ExtendedTextMessage_FontType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.font_ = value;
+}
+inline void Message_ExtendedTextMessage::set_font(::proto::Message_ExtendedTextMessage_FontType value) {
+  _internal_set_font(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.font)
+}
+
+// optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
+inline bool Message_ExtendedTextMessage::_internal_has_previewtype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_previewtype() const {
+  return _internal_has_previewtype();
+}
+inline void Message_ExtendedTextMessage::clear_previewtype() {
+  _impl_.previewtype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::_internal_previewtype() const {
+  return static_cast< ::proto::Message_ExtendedTextMessage_PreviewType >(_impl_.previewtype_);
+}
+inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::previewtype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.previewType)
+  return _internal_previewtype();
+}
+inline void Message_ExtendedTextMessage::_internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) {
+  assert(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.previewtype_ = value;
+}
+inline void Message_ExtendedTextMessage::set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) {
+  _internal_set_previewtype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.previewType)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_ExtendedTextMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_ExtendedTextMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_ExtendedTextMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.jpegThumbnail)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_ExtendedTextMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ExtendedTextMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::ContextInfo& Message_ExtendedTextMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ExtendedTextMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ExtendedTextMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ExtendedTextMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ExtendedTextMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ExtendedTextMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ExtendedTextMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ExtendedTextMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ExtendedTextMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.contextInfo)
+}
+
+// optional bool doNotPlayInline = 18;
+inline bool Message_ExtendedTextMessage::_internal_has_donotplayinline() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_donotplayinline() const {
+  return _internal_has_donotplayinline();
+}
+inline void Message_ExtendedTextMessage::clear_donotplayinline() {
+  _impl_.donotplayinline_ = false;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline bool Message_ExtendedTextMessage::_internal_donotplayinline() const {
+  return _impl_.donotplayinline_;
+}
+inline bool Message_ExtendedTextMessage::donotplayinline() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.doNotPlayInline)
+  return _internal_donotplayinline();
+}
+inline void Message_ExtendedTextMessage::_internal_set_donotplayinline(bool value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.donotplayinline_ = value;
+}
+inline void Message_ExtendedTextMessage::set_donotplayinline(bool value) {
+  _internal_set_donotplayinline(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.doNotPlayInline)
+}
+
+// optional string thumbnailDirectPath = 19;
+inline bool Message_ExtendedTextMessage::_internal_has_thumbnaildirectpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_thumbnaildirectpath() const {
+  return _internal_has_thumbnaildirectpath();
+}
+inline void Message_ExtendedTextMessage::clear_thumbnaildirectpath() {
+  _impl_.thumbnaildirectpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_ExtendedTextMessage::thumbnaildirectpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
+  return _internal_thumbnaildirectpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_thumbnaildirectpath() {
+  std::string* _s = _internal_mutable_thumbnaildirectpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_thumbnaildirectpath() const {
+  return _impl_.thumbnaildirectpath_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnaildirectpath() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_thumbnaildirectpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
+  if (!_internal_has_thumbnaildirectpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.thumbnaildirectpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
+  if (thumbnaildirectpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
+}
+
+// optional bytes thumbnailSha256 = 20;
+inline bool Message_ExtendedTextMessage::_internal_has_thumbnailsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_thumbnailsha256() const {
+  return _internal_has_thumbnailsha256();
+}
+inline void Message_ExtendedTextMessage::clear_thumbnailsha256() {
+  _impl_.thumbnailsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_ExtendedTextMessage::thumbnailsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailSha256)
+  return _internal_thumbnailsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailSha256)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_thumbnailsha256() {
+  std::string* _s = _internal_mutable_thumbnailsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailSha256)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailsha256() const {
+  return _impl_.thumbnailsha256_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_thumbnailsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailsha256() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_thumbnailsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailSha256)
+  if (!_internal_has_thumbnailsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.thumbnailsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
+  if (thumbnailsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailSha256)
+}
+
+// optional bytes thumbnailEncSha256 = 21;
+inline bool Message_ExtendedTextMessage::_internal_has_thumbnailencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_thumbnailencsha256() const {
+  return _internal_has_thumbnailencsha256();
+}
+inline void Message_ExtendedTextMessage::clear_thumbnailencsha256() {
+  _impl_.thumbnailencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& Message_ExtendedTextMessage::thumbnailencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
+  return _internal_thumbnailencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_thumbnailencsha256() {
+  std::string* _s = _internal_mutable_thumbnailencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailencsha256() const {
+  return _impl_.thumbnailencsha256_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_thumbnailencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailencsha256() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_thumbnailencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
+  if (!_internal_has_thumbnailencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.thumbnailencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
+  if (thumbnailencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
+}
+
+// optional bytes mediaKey = 22;
+inline bool Message_ExtendedTextMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_ExtendedTextMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& Message_ExtendedTextMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKey)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.mediaKey)
+}
+
+// optional int64 mediaKeyTimestamp = 23;
+inline bool Message_ExtendedTextMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_ExtendedTextMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline int64_t Message_ExtendedTextMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_ExtendedTextMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_ExtendedTextMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_ExtendedTextMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKeyTimestamp)
+}
+
+// optional uint32 thumbnailHeight = 24;
+inline bool Message_ExtendedTextMessage::_internal_has_thumbnailheight() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_thumbnailheight() const {
+  return _internal_has_thumbnailheight();
+}
+inline void Message_ExtendedTextMessage::clear_thumbnailheight() {
+  _impl_.thumbnailheight_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailheight() const {
+  return _impl_.thumbnailheight_;
+}
+inline uint32_t Message_ExtendedTextMessage::thumbnailheight() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailHeight)
+  return _internal_thumbnailheight();
+}
+inline void Message_ExtendedTextMessage::_internal_set_thumbnailheight(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.thumbnailheight_ = value;
+}
+inline void Message_ExtendedTextMessage::set_thumbnailheight(uint32_t value) {
+  _internal_set_thumbnailheight(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailHeight)
+}
+
+// optional uint32 thumbnailWidth = 25;
+inline bool Message_ExtendedTextMessage::_internal_has_thumbnailwidth() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_thumbnailwidth() const {
+  return _internal_has_thumbnailwidth();
+}
+inline void Message_ExtendedTextMessage::clear_thumbnailwidth() {
+  _impl_.thumbnailwidth_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailwidth() const {
+  return _impl_.thumbnailwidth_;
+}
+inline uint32_t Message_ExtendedTextMessage::thumbnailwidth() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailWidth)
+  return _internal_thumbnailwidth();
+}
+inline void Message_ExtendedTextMessage::_internal_set_thumbnailwidth(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.thumbnailwidth_ = value;
+}
+inline void Message_ExtendedTextMessage::set_thumbnailwidth(uint32_t value) {
+  _internal_set_thumbnailwidth(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailWidth)
+}
+
+// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
+inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_invitelinkgrouptype() const {
+  return _internal_has_invitelinkgrouptype();
+}
+inline void Message_ExtendedTextMessage::clear_invitelinkgrouptype() {
+  _impl_.invitelinkgrouptype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptype() const {
+  return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptype_);
+}
+inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupType)
+  return _internal_invitelinkgrouptype();
+}
+inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
+  assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.invitelinkgrouptype_ = value;
+}
+inline void Message_ExtendedTextMessage::set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
+  _internal_set_invitelinkgrouptype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupType)
+}
+
+// optional string inviteLinkParentGroupSubjectV2 = 27;
+inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupsubjectv2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupsubjectv2() const {
+  return _internal_has_invitelinkparentgroupsubjectv2();
+}
+inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupsubjectv2() {
+  _impl_.invitelinkparentgroupsubjectv2_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupsubjectv2() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
+  return _internal_invitelinkparentgroupsubjectv2();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.invitelinkparentgroupsubjectv2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupsubjectv2() {
+  std::string* _s = _internal_mutable_invitelinkparentgroupsubjectv2();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupsubjectv2() const {
+  return _impl_.invitelinkparentgroupsubjectv2_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupsubjectv2(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.invitelinkparentgroupsubjectv2_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupsubjectv2() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.invitelinkparentgroupsubjectv2_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupsubjectv2() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
+  if (!_internal_has_invitelinkparentgroupsubjectv2()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.invitelinkparentgroupsubjectv2_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) {
+    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2) {
+  if (invitelinkparentgroupsubjectv2 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.invitelinkparentgroupsubjectv2_.SetAllocated(invitelinkparentgroupsubjectv2, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) {
+    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
+}
+
+// optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupthumbnailv2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupthumbnailv2() const {
+  return _internal_has_invitelinkparentgroupthumbnailv2();
+}
+inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupthumbnailv2() {
+  _impl_.invitelinkparentgroupthumbnailv2_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupthumbnailv2() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
+  return _internal_invitelinkparentgroupthumbnailv2();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ExtendedTextMessage::set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.invitelinkparentgroupthumbnailv2_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
+}
+inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupthumbnailv2() {
+  std::string* _s = _internal_mutable_invitelinkparentgroupthumbnailv2();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
+  return _s;
+}
+inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupthumbnailv2() const {
+  return _impl_.invitelinkparentgroupthumbnailv2_.Get();
+}
+inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupthumbnailv2(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.invitelinkparentgroupthumbnailv2_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupthumbnailv2() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.invitelinkparentgroupthumbnailv2_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupthumbnailv2() {
+  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
+  if (!_internal_has_invitelinkparentgroupthumbnailv2()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.invitelinkparentgroupthumbnailv2_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) {
+    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2) {
+  if (invitelinkparentgroupthumbnailv2 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.invitelinkparentgroupthumbnailv2_.SetAllocated(invitelinkparentgroupthumbnailv2, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) {
+    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
+}
+
+// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptypev2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool Message_ExtendedTextMessage::has_invitelinkgrouptypev2() const {
+  return _internal_has_invitelinkgrouptypev2();
+}
+inline void Message_ExtendedTextMessage::clear_invitelinkgrouptypev2() {
+  _impl_.invitelinkgrouptypev2_ = 0;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptypev2() const {
+  return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptypev2_);
+}
+inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptypev2() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2)
+  return _internal_invitelinkgrouptypev2();
+}
+inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
+  assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.invitelinkgrouptypev2_ = value;
+}
+inline void Message_ExtendedTextMessage::set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
+  _internal_set_invitelinkgrouptypev2(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2)
+}
+
+// -------------------------------------------------------------------
+
+// Message_FutureProofMessage
+
+// optional .proto.Message message = 1;
+inline bool Message_FutureProofMessage::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
+  return value;
+}
+inline bool Message_FutureProofMessage::has_message() const {
+  return _internal_has_message();
+}
+inline void Message_FutureProofMessage::clear_message() {
+  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message& Message_FutureProofMessage::_internal_message() const {
+  const ::proto::Message* p = _impl_.message_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& Message_FutureProofMessage::message() const {
+  // @@protoc_insertion_point(field_get:proto.Message.FutureProofMessage.message)
+  return _internal_message();
+}
+inline void Message_FutureProofMessage::unsafe_arena_set_allocated_message(
+    ::proto::Message* message) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
+  }
+  _impl_.message_ = message;
+  if (message) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.FutureProofMessage.message)
+}
+inline ::proto::Message* Message_FutureProofMessage::release_message() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* Message_FutureProofMessage::unsafe_arena_release_message() {
+  // @@protoc_insertion_point(field_release:proto.Message.FutureProofMessage.message)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* Message_FutureProofMessage::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.message_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.message_ = p;
+  }
+  return _impl_.message_;
+}
+inline ::proto::Message* Message_FutureProofMessage::mutable_message() {
+  ::proto::Message* _msg = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.Message.FutureProofMessage.message)
+  return _msg;
+}
+inline void Message_FutureProofMessage::set_allocated_message(::proto::Message* message) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.message_;
+  }
+  if (message) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
+    if (message_arena != submessage_arena) {
+      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, message, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.message_ = message;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.FutureProofMessage.message)
+}
+
+// -------------------------------------------------------------------
+
+// Message_GroupInviteMessage
+
+// optional string groupJid = 1;
+inline bool Message_GroupInviteMessage::_internal_has_groupjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_groupjid() const {
+  return _internal_has_groupjid();
+}
+inline void Message_GroupInviteMessage::clear_groupjid() {
+  _impl_.groupjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_GroupInviteMessage::groupjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupJid)
+  return _internal_groupjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_GroupInviteMessage::set_groupjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.groupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupJid)
+}
+inline std::string* Message_GroupInviteMessage::mutable_groupjid() {
+  std::string* _s = _internal_mutable_groupjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupJid)
+  return _s;
+}
+inline const std::string& Message_GroupInviteMessage::_internal_groupjid() const {
+  return _impl_.groupjid_.Get();
+}
+inline void Message_GroupInviteMessage::_internal_set_groupjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.groupjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::_internal_mutable_groupjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.groupjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::release_groupjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupJid)
+  if (!_internal_has_groupjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.groupjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupjid_.IsDefault()) {
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_GroupInviteMessage::set_allocated_groupjid(std::string* groupjid) {
+  if (groupjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupjid_.IsDefault()) {
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupJid)
+}
+
+// optional string inviteCode = 2;
+inline bool Message_GroupInviteMessage::_internal_has_invitecode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_invitecode() const {
+  return _internal_has_invitecode();
+}
+inline void Message_GroupInviteMessage::clear_invitecode() {
+  _impl_.invitecode_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_GroupInviteMessage::invitecode() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteCode)
+  return _internal_invitecode();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_GroupInviteMessage::set_invitecode(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.invitecode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteCode)
+}
+inline std::string* Message_GroupInviteMessage::mutable_invitecode() {
+  std::string* _s = _internal_mutable_invitecode();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.inviteCode)
+  return _s;
+}
+inline const std::string& Message_GroupInviteMessage::_internal_invitecode() const {
+  return _impl_.invitecode_.Get();
+}
+inline void Message_GroupInviteMessage::_internal_set_invitecode(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.invitecode_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::_internal_mutable_invitecode() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.invitecode_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::release_invitecode() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.inviteCode)
+  if (!_internal_has_invitecode()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.invitecode_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitecode_.IsDefault()) {
+    _impl_.invitecode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_GroupInviteMessage::set_allocated_invitecode(std::string* invitecode) {
+  if (invitecode != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.invitecode_.SetAllocated(invitecode, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.invitecode_.IsDefault()) {
+    _impl_.invitecode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.inviteCode)
+}
+
+// optional int64 inviteExpiration = 3;
+inline bool Message_GroupInviteMessage::_internal_has_inviteexpiration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_inviteexpiration() const {
+  return _internal_has_inviteexpiration();
+}
+inline void Message_GroupInviteMessage::clear_inviteexpiration() {
+  _impl_.inviteexpiration_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline int64_t Message_GroupInviteMessage::_internal_inviteexpiration() const {
+  return _impl_.inviteexpiration_;
+}
+inline int64_t Message_GroupInviteMessage::inviteexpiration() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteExpiration)
+  return _internal_inviteexpiration();
+}
+inline void Message_GroupInviteMessage::_internal_set_inviteexpiration(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.inviteexpiration_ = value;
+}
+inline void Message_GroupInviteMessage::set_inviteexpiration(int64_t value) {
+  _internal_set_inviteexpiration(value);
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteExpiration)
+}
+
+// optional string groupName = 4;
+inline bool Message_GroupInviteMessage::_internal_has_groupname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_groupname() const {
+  return _internal_has_groupname();
+}
+inline void Message_GroupInviteMessage::clear_groupname() {
+  _impl_.groupname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_GroupInviteMessage::groupname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupName)
+  return _internal_groupname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_GroupInviteMessage::set_groupname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.groupname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupName)
+}
+inline std::string* Message_GroupInviteMessage::mutable_groupname() {
+  std::string* _s = _internal_mutable_groupname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupName)
+  return _s;
+}
+inline const std::string& Message_GroupInviteMessage::_internal_groupname() const {
+  return _impl_.groupname_.Get();
+}
+inline void Message_GroupInviteMessage::_internal_set_groupname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.groupname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::_internal_mutable_groupname() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.groupname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::release_groupname() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupName)
+  if (!_internal_has_groupname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.groupname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupname_.IsDefault()) {
+    _impl_.groupname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_GroupInviteMessage::set_allocated_groupname(std::string* groupname) {
+  if (groupname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.groupname_.SetAllocated(groupname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupname_.IsDefault()) {
+    _impl_.groupname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupName)
+}
+
+// optional bytes jpegThumbnail = 5;
+inline bool Message_GroupInviteMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_GroupInviteMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_GroupInviteMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_GroupInviteMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.jpegThumbnail)
+}
+inline std::string* Message_GroupInviteMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_GroupInviteMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_GroupInviteMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_GroupInviteMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.jpegThumbnail)
+}
+
+// optional string caption = 6;
+inline bool Message_GroupInviteMessage::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_caption() const {
+  return _internal_has_caption();
+}
+inline void Message_GroupInviteMessage::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_GroupInviteMessage::caption() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_GroupInviteMessage::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.caption)
+}
+inline std::string* Message_GroupInviteMessage::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.caption)
+  return _s;
+}
+inline const std::string& Message_GroupInviteMessage::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void Message_GroupInviteMessage::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_GroupInviteMessage::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_GroupInviteMessage::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.caption)
+}
+
+// optional .proto.ContextInfo contextInfo = 7;
+inline bool Message_GroupInviteMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_GroupInviteMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ContextInfo& Message_GroupInviteMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_GroupInviteMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_GroupInviteMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.GroupInviteMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_GroupInviteMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_GroupInviteMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_GroupInviteMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_GroupInviteMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.contextInfo)
+  return _msg;
+}
+inline void Message_GroupInviteMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.contextInfo)
+}
+
+// optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
+inline bool Message_GroupInviteMessage::_internal_has_grouptype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_GroupInviteMessage::has_grouptype() const {
+  return _internal_has_grouptype();
+}
+inline void Message_GroupInviteMessage::clear_grouptype() {
+  _impl_.grouptype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::_internal_grouptype() const {
+  return static_cast< ::proto::Message_GroupInviteMessage_GroupType >(_impl_.grouptype_);
+}
+inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::grouptype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupType)
+  return _internal_grouptype();
+}
+inline void Message_GroupInviteMessage::_internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) {
+  assert(::proto::Message_GroupInviteMessage_GroupType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.grouptype_ = value;
+}
+inline void Message_GroupInviteMessage::set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) {
+  _internal_set_grouptype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupType)
+}
+
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency
+
+// optional string currencyCode = 1;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_currencycode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_currencycode() const {
+  return _internal_has_currencycode();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_currencycode() {
+  _impl_.currencycode_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::currencycode() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
+  return _internal_currencycode();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_currencycode(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::mutable_currencycode() {
+  std::string* _s = _internal_mutable_currencycode();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_currencycode() const {
+  return _impl_.currencycode_.Get();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_currencycode(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.currencycode_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_mutable_currencycode() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::release_currencycode() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
+  if (!_internal_has_currencycode()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.currencycode_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_allocated_currencycode(std::string* currencycode) {
+  if (currencycode != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
+}
+
+// optional int64 amount1000 = 2;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_amount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_amount1000() const {
+  return _internal_has_amount1000();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_amount1000() {
+  _impl_.amount1000_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_amount1000() const {
+  return _impl_.amount1000_;
+}
+inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::amount1000() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000)
+  return _internal_amount1000();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_amount1000(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.amount1000_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_amount1000(int64_t value) {
+  _internal_set_amount1000(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000)
+}
+
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent
+
+// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofweek() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofweek() const {
+  return _internal_has_dayofweek();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofweek() {
+  _impl_.dayofweek_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofweek() const {
+  return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType >(_impl_.dayofweek_);
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofweek() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek)
+  return _internal_dayofweek();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) {
+  assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.dayofweek_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) {
+  _internal_set_dayofweek(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek)
+}
+
+// optional uint32 year = 2;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_year() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_year() const {
+  return _internal_has_year();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_year() {
+  _impl_.year_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_year() const {
+  return _impl_.year_;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::year() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year)
+  return _internal_year();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_year(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.year_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_year(uint32_t value) {
+  _internal_set_year(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year)
+}
+
+// optional uint32 month = 3;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_month() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_month() const {
+  return _internal_has_month();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_month() {
+  _impl_.month_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_month() const {
+  return _impl_.month_;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::month() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month)
+  return _internal_month();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_month(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.month_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_month(uint32_t value) {
+  _internal_set_month(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month)
+}
+
+// optional uint32 dayOfMonth = 4;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofmonth() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofmonth() const {
+  return _internal_has_dayofmonth();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofmonth() {
+  _impl_.dayofmonth_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofmonth() const {
+  return _impl_.dayofmonth_;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofmonth() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth)
+  return _internal_dayofmonth();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofmonth(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.dayofmonth_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofmonth(uint32_t value) {
+  _internal_set_dayofmonth(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth)
+}
+
+// optional uint32 hour = 5;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_hour() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_hour() const {
+  return _internal_has_hour();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_hour() {
+  _impl_.hour_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_hour() const {
+  return _impl_.hour_;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::hour() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour)
+  return _internal_hour();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_hour(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.hour_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_hour(uint32_t value) {
+  _internal_set_hour(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour)
+}
+
+// optional uint32 minute = 6;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_minute() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_minute() const {
+  return _internal_has_minute();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_minute() {
+  _impl_.minute_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_minute() const {
+  return _impl_.minute_;
+}
+inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::minute() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute)
+  return _internal_minute();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_minute(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.minute_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_minute(uint32_t value) {
+  _internal_set_minute(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute)
+}
+
+// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_calendar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_calendar() const {
+  return _internal_has_calendar();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_calendar() {
+  _impl_.calendar_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_calendar() const {
+  return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType >(_impl_.calendar_);
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::calendar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar)
+  return _internal_calendar();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) {
+  assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.calendar_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) {
+  _internal_set_calendar(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar)
+}
+
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch
+
+// optional int64 timestamp = 1;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp)
+  return _internal_timestamp();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime
+
+// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_component() const {
+  return datetimeOneof_case() == kComponent;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_component() const {
+  return _internal_has_component();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_component() {
+  _impl_._oneof_case_[0] = kComponent;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_component() {
+  if (_internal_has_component()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.datetimeOneof_.component_;
+    }
+    clear_has_datetimeOneof();
+  }
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_component() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+  if (_internal_has_component()) {
+    clear_has_datetimeOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.datetimeOneof_.component_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_component() const {
+  return _internal_has_component()
+      ? *_impl_.datetimeOneof_.component_
+      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::component() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+  return _internal_component();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_component() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+  if (_internal_has_component()) {
+    clear_has_datetimeOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_;
+    _impl_.datetimeOneof_.component_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) {
+  clear_datetimeOneof();
+  if (component) {
+    set_has_component();
+    _impl_.datetimeOneof_.component_ = component;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_component() {
+  if (!_internal_has_component()) {
+    clear_datetimeOneof();
+    set_has_component();
+    _impl_.datetimeOneof_.component_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(GetArenaForAllocation());
+  }
+  return _impl_.datetimeOneof_.component_;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_component() {
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _msg = _internal_mutable_component();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
+  return _msg;
+}
+
+// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_unixepoch() const {
+  return datetimeOneof_case() == kUnixEpoch;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_unixepoch() const {
+  return _internal_has_unixepoch();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_unixepoch() {
+  _impl_._oneof_case_[0] = kUnixEpoch;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_unixepoch() {
+  if (_internal_has_unixepoch()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.datetimeOneof_.unixepoch_;
+    }
+    clear_has_datetimeOneof();
+  }
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_unixepoch() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+  if (_internal_has_unixepoch()) {
+    clear_has_datetimeOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.datetimeOneof_.unixepoch_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_unixepoch() const {
+  return _internal_has_unixepoch()
+      ? *_impl_.datetimeOneof_.unixepoch_
+      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unixepoch() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+  return _internal_unixepoch();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_unixepoch() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+  if (_internal_has_unixepoch()) {
+    clear_has_datetimeOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_;
+    _impl_.datetimeOneof_.unixepoch_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) {
+  clear_datetimeOneof();
+  if (unixepoch) {
+    set_has_unixepoch();
+    _impl_.datetimeOneof_.unixepoch_ = unixepoch;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_unixepoch() {
+  if (!_internal_has_unixepoch()) {
+    clear_datetimeOneof();
+    set_has_unixepoch();
+    _impl_.datetimeOneof_.unixepoch_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(GetArenaForAllocation());
+  }
+  return _impl_.datetimeOneof_.unixepoch_;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_unixepoch() {
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _msg = _internal_mutable_unixepoch();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
+  return _msg;
+}
+
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_datetimeOneof() const {
+  return datetimeOneof_case() != DATETIMEONEOF_NOT_SET;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_has_datetimeOneof() {
+  _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET;
+}
+inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::datetimeOneof_case() const {
+  return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage_HSMLocalizableParameter
+
+// optional string default = 1;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_default_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_default_() const {
+  return _internal_has_default_();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_default_() {
+  _impl_.default__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::default_() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
+  return _internal_default_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_default_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.default__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_default_() {
+  std::string* _s = _internal_mutable_default_();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_default_() const {
+  return _impl_.default__.Get();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_set_default_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.default__.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_default_() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.default__.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_default_() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
+  if (!_internal_has_default_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.default__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.default__.IsDefault()) {
+    _impl_.default__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_default_(std::string* default_) {
+  if (default_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.default__.SetAllocated(default_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.default__.IsDefault()) {
+    _impl_.default__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
+}
+
+// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_currency() const {
+  return paramOneof_case() == kCurrency;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_currency() const {
+  return _internal_has_currency();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_currency() {
+  _impl_._oneof_case_[0] = kCurrency;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_currency() {
+  if (_internal_has_currency()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.paramOneof_.currency_;
+    }
+    clear_has_paramOneof();
+  }
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_currency() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+  if (_internal_has_currency()) {
+    clear_has_paramOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.paramOneof_.currency_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_currency() const {
+  return _internal_has_currency()
+      ? *_impl_.paramOneof_.currency_
+      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::currency() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+  return _internal_currency();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_currency() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+  if (_internal_has_currency()) {
+    clear_has_paramOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_;
+    _impl_.paramOneof_.currency_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) {
+  clear_paramOneof();
+  if (currency) {
+    set_has_currency();
+    _impl_.paramOneof_.currency_ = currency;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_currency() {
+  if (!_internal_has_currency()) {
+    clear_paramOneof();
+    set_has_currency();
+    _impl_.paramOneof_.currency_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(GetArenaForAllocation());
+  }
+  return _impl_.paramOneof_.currency_;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_currency() {
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _msg = _internal_mutable_currency();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
+  return _msg;
+}
+
+// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_datetime() const {
+  return paramOneof_case() == kDateTime;
+}
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_datetime() const {
+  return _internal_has_datetime();
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_datetime() {
+  _impl_._oneof_case_[0] = kDateTime;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_datetime() {
+  if (_internal_has_datetime()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.paramOneof_.datetime_;
+    }
+    clear_has_paramOneof();
+  }
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_datetime() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+  if (_internal_has_datetime()) {
+    clear_has_paramOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.paramOneof_.datetime_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_datetime() const {
+  return _internal_has_datetime()
+      ? *_impl_.paramOneof_.datetime_
+      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::datetime() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+  return _internal_datetime();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_datetime() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+  if (_internal_has_datetime()) {
+    clear_has_paramOneof();
+    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_;
+    _impl_.paramOneof_.datetime_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) {
+  clear_paramOneof();
+  if (datetime) {
+    set_has_datetime();
+    _impl_.paramOneof_.datetime_ = datetime;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_datetime() {
+  if (!_internal_has_datetime()) {
+    clear_paramOneof();
+    set_has_datetime();
+    _impl_.paramOneof_.datetime_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(GetArenaForAllocation());
+  }
+  return _impl_.paramOneof_.datetime_;
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_datetime() {
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _msg = _internal_mutable_datetime();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
+  return _msg;
+}
+
+inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_paramOneof() const {
+  return paramOneof_case() != PARAMONEOF_NOT_SET;
+}
+inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_has_paramOneof() {
+  _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET;
+}
+inline Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter::paramOneof_case() const {
+  return Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_HighlyStructuredMessage
+
+// optional string namespace = 1;
+inline bool Message_HighlyStructuredMessage::_internal_has_namespace_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_namespace_() const {
+  return _internal_has_namespace_();
+}
+inline void Message_HighlyStructuredMessage::clear_namespace_() {
+  _impl_.namespace__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_HighlyStructuredMessage::namespace_() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.namespace)
+  return _internal_namespace_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_namespace_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.namespace)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_namespace_() {
+  std::string* _s = _internal_mutable_namespace_();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.namespace)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_namespace_() const {
+  return _impl_.namespace__.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_namespace_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.namespace__.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_namespace_() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.namespace__.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_namespace_() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.namespace)
+  if (!_internal_has_namespace_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.namespace__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.namespace__.IsDefault()) {
+    _impl_.namespace__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_namespace_(std::string* namespace_) {
+  if (namespace_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.namespace__.IsDefault()) {
+    _impl_.namespace__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.namespace)
+}
+
+// optional string elementName = 2;
+inline bool Message_HighlyStructuredMessage::_internal_has_elementname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_elementname() const {
+  return _internal_has_elementname();
+}
+inline void Message_HighlyStructuredMessage::clear_elementname() {
+  _impl_.elementname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_HighlyStructuredMessage::elementname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.elementName)
+  return _internal_elementname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_elementname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.elementname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.elementName)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_elementname() {
+  std::string* _s = _internal_mutable_elementname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.elementName)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_elementname() const {
+  return _impl_.elementname_.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_elementname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.elementname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_elementname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.elementname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_elementname() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.elementName)
+  if (!_internal_has_elementname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.elementname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.elementname_.IsDefault()) {
+    _impl_.elementname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_elementname(std::string* elementname) {
+  if (elementname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.elementname_.SetAllocated(elementname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.elementname_.IsDefault()) {
+    _impl_.elementname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.elementName)
+}
+
+// repeated string params = 3;
+inline int Message_HighlyStructuredMessage::_internal_params_size() const {
+  return _impl_.params_.size();
+}
+inline int Message_HighlyStructuredMessage::params_size() const {
+  return _internal_params_size();
+}
+inline void Message_HighlyStructuredMessage::clear_params() {
+  _impl_.params_.Clear();
+}
+inline std::string* Message_HighlyStructuredMessage::add_params() {
+  std::string* _s = _internal_add_params();
+  // @@protoc_insertion_point(field_add_mutable:proto.Message.HighlyStructuredMessage.params)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_params(int index) const {
+  return _impl_.params_.Get(index);
+}
+inline const std::string& Message_HighlyStructuredMessage::params(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.params)
+  return _internal_params(index);
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_params(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.params)
+  return _impl_.params_.Mutable(index);
+}
+inline void Message_HighlyStructuredMessage::set_params(int index, const std::string& value) {
+  _impl_.params_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::set_params(int index, std::string&& value) {
+  _impl_.params_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::set_params(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.params_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::set_params(int index, const char* value, size_t size) {
+  _impl_.params_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.Message.HighlyStructuredMessage.params)
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_add_params() {
+  return _impl_.params_.Add();
+}
+inline void Message_HighlyStructuredMessage::add_params(const std::string& value) {
+  _impl_.params_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::add_params(std::string&& value) {
+  _impl_.params_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::add_params(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.params_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.Message.HighlyStructuredMessage.params)
+}
+inline void Message_HighlyStructuredMessage::add_params(const char* value, size_t size) {
+  _impl_.params_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.Message.HighlyStructuredMessage.params)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Message_HighlyStructuredMessage::params() const {
+  // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.params)
+  return _impl_.params_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Message_HighlyStructuredMessage::mutable_params() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.params)
+  return &_impl_.params_;
+}
+
+// optional string fallbackLg = 4;
+inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_fallbacklg() const {
+  return _internal_has_fallbacklg();
+}
+inline void Message_HighlyStructuredMessage::clear_fallbacklg() {
+  _impl_.fallbacklg_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_HighlyStructuredMessage::fallbacklg() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLg)
+  return _internal_fallbacklg();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_fallbacklg(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fallbacklg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLg)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklg() {
+  std::string* _s = _internal_mutable_fallbacklg();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLg)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklg() const {
+  return _impl_.fallbacklg_.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_fallbacklg(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fallbacklg_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklg() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fallbacklg_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_fallbacklg() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLg)
+  if (!_internal_has_fallbacklg()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fallbacklg_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fallbacklg_.IsDefault()) {
+    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_fallbacklg(std::string* fallbacklg) {
+  if (fallbacklg != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fallbacklg_.SetAllocated(fallbacklg, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fallbacklg_.IsDefault()) {
+    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLg)
+}
+
+// optional string fallbackLc = 5;
+inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_fallbacklc() const {
+  return _internal_has_fallbacklc();
+}
+inline void Message_HighlyStructuredMessage::clear_fallbacklc() {
+  _impl_.fallbacklc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_HighlyStructuredMessage::fallbacklc() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLc)
+  return _internal_fallbacklc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_fallbacklc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.fallbacklc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLc)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklc() {
+  std::string* _s = _internal_mutable_fallbacklc();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLc)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklc() const {
+  return _impl_.fallbacklc_.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_fallbacklc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.fallbacklc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklc() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.fallbacklc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_fallbacklc() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLc)
+  if (!_internal_has_fallbacklc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.fallbacklc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fallbacklc_.IsDefault()) {
+    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_fallbacklc(std::string* fallbacklc) {
+  if (fallbacklc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.fallbacklc_.SetAllocated(fallbacklc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fallbacklc_.IsDefault()) {
+    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLc)
+}
+
+// repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
+inline int Message_HighlyStructuredMessage::_internal_localizableparams_size() const {
+  return _impl_.localizableparams_.size();
+}
+inline int Message_HighlyStructuredMessage::localizableparams_size() const {
+  return _internal_localizableparams_size();
+}
+inline void Message_HighlyStructuredMessage::clear_localizableparams() {
+  _impl_.localizableparams_.Clear();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::mutable_localizableparams(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.localizableParams)
+  return _impl_.localizableparams_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >*
+Message_HighlyStructuredMessage::mutable_localizableparams() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.localizableParams)
+  return &_impl_.localizableparams_;
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::_internal_localizableparams(int index) const {
+  return _impl_.localizableparams_.Get(index);
+}
+inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::localizableparams(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.localizableParams)
+  return _internal_localizableparams(index);
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::_internal_add_localizableparams() {
+  return _impl_.localizableparams_.Add();
+}
+inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::add_localizableparams() {
+  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _add = _internal_add_localizableparams();
+  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.localizableParams)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >&
+Message_HighlyStructuredMessage::localizableparams() const {
+  // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.localizableParams)
+  return _impl_.localizableparams_;
+}
+
+// optional string deterministicLg = 7;
+inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_deterministiclg() const {
+  return _internal_has_deterministiclg();
+}
+inline void Message_HighlyStructuredMessage::clear_deterministiclg() {
+  _impl_.deterministiclg_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_HighlyStructuredMessage::deterministiclg() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLg)
+  return _internal_deterministiclg();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_deterministiclg(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.deterministiclg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLg)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclg() {
+  std::string* _s = _internal_mutable_deterministiclg();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLg)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclg() const {
+  return _impl_.deterministiclg_.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_deterministiclg(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.deterministiclg_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclg() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.deterministiclg_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_deterministiclg() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLg)
+  if (!_internal_has_deterministiclg()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.deterministiclg_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deterministiclg_.IsDefault()) {
+    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_deterministiclg(std::string* deterministiclg) {
+  if (deterministiclg != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.deterministiclg_.SetAllocated(deterministiclg, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deterministiclg_.IsDefault()) {
+    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLg)
+}
+
+// optional string deterministicLc = 8;
+inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_deterministiclc() const {
+  return _internal_has_deterministiclc();
+}
+inline void Message_HighlyStructuredMessage::clear_deterministiclc() {
+  _impl_.deterministiclc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_HighlyStructuredMessage::deterministiclc() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLc)
+  return _internal_deterministiclc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HighlyStructuredMessage::set_deterministiclc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.deterministiclc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLc)
+}
+inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclc() {
+  std::string* _s = _internal_mutable_deterministiclc();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLc)
+  return _s;
+}
+inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclc() const {
+  return _impl_.deterministiclc_.Get();
+}
+inline void Message_HighlyStructuredMessage::_internal_set_deterministiclc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.deterministiclc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclc() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.deterministiclc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HighlyStructuredMessage::release_deterministiclc() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLc)
+  if (!_internal_has_deterministiclc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.deterministiclc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deterministiclc_.IsDefault()) {
+    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_deterministiclc(std::string* deterministiclc) {
+  if (deterministiclc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.deterministiclc_.SetAllocated(deterministiclc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deterministiclc_.IsDefault()) {
+    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLc)
+}
+
+// optional .proto.Message.TemplateMessage hydratedHsm = 9;
+inline bool Message_HighlyStructuredMessage::_internal_has_hydratedhsm() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.hydratedhsm_ != nullptr);
+  return value;
+}
+inline bool Message_HighlyStructuredMessage::has_hydratedhsm() const {
+  return _internal_has_hydratedhsm();
+}
+inline void Message_HighlyStructuredMessage::clear_hydratedhsm() {
+  if (_impl_.hydratedhsm_ != nullptr) _impl_.hydratedhsm_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::_internal_hydratedhsm() const {
+  const ::proto::Message_TemplateMessage* p = _impl_.hydratedhsm_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage&>(
+      ::proto::_Message_TemplateMessage_default_instance_);
+}
+inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::hydratedhsm() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.hydratedHsm)
+  return _internal_hydratedhsm();
+}
+inline void Message_HighlyStructuredMessage::unsafe_arena_set_allocated_hydratedhsm(
+    ::proto::Message_TemplateMessage* hydratedhsm) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedhsm_);
+  }
+  _impl_.hydratedhsm_ = hydratedhsm;
+  if (hydratedhsm) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm)
+}
+inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::release_hydratedhsm() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_;
+  _impl_.hydratedhsm_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::unsafe_arena_release_hydratedhsm() {
+  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.hydratedHsm)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_;
+  _impl_.hydratedhsm_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::_internal_mutable_hydratedhsm() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.hydratedhsm_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation());
+    _impl_.hydratedhsm_ = p;
+  }
+  return _impl_.hydratedhsm_;
+}
+inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::mutable_hydratedhsm() {
+  ::proto::Message_TemplateMessage* _msg = _internal_mutable_hydratedhsm();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.hydratedHsm)
+  return _msg;
+}
+inline void Message_HighlyStructuredMessage::set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.hydratedhsm_;
+  }
+  if (hydratedhsm) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedhsm);
+    if (message_arena != submessage_arena) {
+      hydratedhsm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, hydratedhsm, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.hydratedhsm_ = hydratedhsm;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm)
+}
+
+// -------------------------------------------------------------------
+
+// Message_HistorySyncNotification
+
+// optional bytes fileSha256 = 1;
+inline bool Message_HistorySyncNotification::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_HistorySyncNotification::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_HistorySyncNotification::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HistorySyncNotification::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileSha256)
+}
+inline std::string* Message_HistorySyncNotification::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileSha256)
+  return _s;
+}
+inline const std::string& Message_HistorySyncNotification::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_HistorySyncNotification::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HistorySyncNotification::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileSha256)
+}
+
+// optional uint64 fileLength = 2;
+inline bool Message_HistorySyncNotification::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_HistorySyncNotification::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint64_t Message_HistorySyncNotification::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_HistorySyncNotification::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileLength)
+  return _internal_filelength();
+}
+inline void Message_HistorySyncNotification::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.filelength_ = value;
+}
+inline void Message_HistorySyncNotification::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileLength)
+}
+
+// optional bytes mediaKey = 3;
+inline bool Message_HistorySyncNotification::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_HistorySyncNotification::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_HistorySyncNotification::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HistorySyncNotification::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.mediaKey)
+}
+inline std::string* Message_HistorySyncNotification::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.mediaKey)
+  return _s;
+}
+inline const std::string& Message_HistorySyncNotification::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_HistorySyncNotification::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HistorySyncNotification::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.mediaKey)
+}
+
+// optional bytes fileEncSha256 = 4;
+inline bool Message_HistorySyncNotification::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_HistorySyncNotification::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_HistorySyncNotification::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HistorySyncNotification::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileEncSha256)
+}
+inline std::string* Message_HistorySyncNotification::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_HistorySyncNotification::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_HistorySyncNotification::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HistorySyncNotification::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileEncSha256)
+}
+
+// optional string directPath = 5;
+inline bool Message_HistorySyncNotification::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_HistorySyncNotification::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_HistorySyncNotification::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HistorySyncNotification::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.directPath)
+}
+inline std::string* Message_HistorySyncNotification::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.directPath)
+  return _s;
+}
+inline const std::string& Message_HistorySyncNotification::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_HistorySyncNotification::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HistorySyncNotification::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.directPath)
+}
+
+// optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
+inline bool Message_HistorySyncNotification::_internal_has_synctype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_synctype() const {
+  return _internal_has_synctype();
+}
+inline void Message_HistorySyncNotification::clear_synctype() {
+  _impl_.synctype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::_internal_synctype() const {
+  return static_cast< ::proto::Message_HistorySyncNotification_HistorySyncType >(_impl_.synctype_);
+}
+inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::synctype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.syncType)
+  return _internal_synctype();
+}
+inline void Message_HistorySyncNotification::_internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) {
+  assert(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.synctype_ = value;
+}
+inline void Message_HistorySyncNotification::set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) {
+  _internal_set_synctype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.syncType)
+}
+
+// optional uint32 chunkOrder = 7;
+inline bool Message_HistorySyncNotification::_internal_has_chunkorder() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_chunkorder() const {
+  return _internal_has_chunkorder();
+}
+inline void Message_HistorySyncNotification::clear_chunkorder() {
+  _impl_.chunkorder_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint32_t Message_HistorySyncNotification::_internal_chunkorder() const {
+  return _impl_.chunkorder_;
+}
+inline uint32_t Message_HistorySyncNotification::chunkorder() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.chunkOrder)
+  return _internal_chunkorder();
+}
+inline void Message_HistorySyncNotification::_internal_set_chunkorder(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.chunkorder_ = value;
+}
+inline void Message_HistorySyncNotification::set_chunkorder(uint32_t value) {
+  _internal_set_chunkorder(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.chunkOrder)
+}
+
+// optional string originalMessageId = 8;
+inline bool Message_HistorySyncNotification::_internal_has_originalmessageid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_originalmessageid() const {
+  return _internal_has_originalmessageid();
+}
+inline void Message_HistorySyncNotification::clear_originalmessageid() {
+  _impl_.originalmessageid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_HistorySyncNotification::originalmessageid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.originalMessageId)
+  return _internal_originalmessageid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_HistorySyncNotification::set_originalmessageid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.originalmessageid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.originalMessageId)
+}
+inline std::string* Message_HistorySyncNotification::mutable_originalmessageid() {
+  std::string* _s = _internal_mutable_originalmessageid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.originalMessageId)
+  return _s;
+}
+inline const std::string& Message_HistorySyncNotification::_internal_originalmessageid() const {
+  return _impl_.originalmessageid_.Get();
+}
+inline void Message_HistorySyncNotification::_internal_set_originalmessageid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.originalmessageid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::_internal_mutable_originalmessageid() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.originalmessageid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_HistorySyncNotification::release_originalmessageid() {
+  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.originalMessageId)
+  if (!_internal_has_originalmessageid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.originalmessageid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.originalmessageid_.IsDefault()) {
+    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_HistorySyncNotification::set_allocated_originalmessageid(std::string* originalmessageid) {
+  if (originalmessageid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.originalmessageid_.SetAllocated(originalmessageid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.originalmessageid_.IsDefault()) {
+    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.originalMessageId)
+}
+
+// optional uint32 progress = 9;
+inline bool Message_HistorySyncNotification::_internal_has_progress() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_HistorySyncNotification::has_progress() const {
+  return _internal_has_progress();
+}
+inline void Message_HistorySyncNotification::clear_progress() {
+  _impl_.progress_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint32_t Message_HistorySyncNotification::_internal_progress() const {
+  return _impl_.progress_;
+}
+inline uint32_t Message_HistorySyncNotification::progress() const {
+  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.progress)
+  return _internal_progress();
+}
+inline void Message_HistorySyncNotification::_internal_set_progress(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.progress_ = value;
+}
+inline void Message_HistorySyncNotification::set_progress(uint32_t value) {
+  _internal_set_progress(value);
+  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.progress)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ImageMessage
+
+// optional string url = 1;
+inline bool Message_ImageMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_ImageMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ImageMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.url)
+}
+inline std::string* Message_ImageMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.url)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_ImageMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.url)
+}
+
+// optional string mimetype = 2;
+inline bool Message_ImageMessage::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void Message_ImageMessage::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ImageMessage::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mimetype)
+}
+inline std::string* Message_ImageMessage::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mimetype)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void Message_ImageMessage::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mimetype)
+}
+
+// optional string caption = 3;
+inline bool Message_ImageMessage::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_caption() const {
+  return _internal_has_caption();
+}
+inline void Message_ImageMessage::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ImageMessage::caption() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.caption)
+}
+inline std::string* Message_ImageMessage::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.caption)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void Message_ImageMessage::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.caption)
+}
+
+// optional bytes fileSha256 = 4;
+inline bool Message_ImageMessage::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_ImageMessage::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_ImageMessage::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileSha256)
+}
+inline std::string* Message_ImageMessage::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileSha256)
+}
+
+// optional uint64 fileLength = 5;
+inline bool Message_ImageMessage::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_ImageMessage::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline uint64_t Message_ImageMessage::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_ImageMessage::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileLength)
+  return _internal_filelength();
+}
+inline void Message_ImageMessage::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.filelength_ = value;
+}
+inline void Message_ImageMessage::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileLength)
+}
+
+// optional uint32 height = 6;
+inline bool Message_ImageMessage::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_height() const {
+  return _internal_has_height();
+}
+inline void Message_ImageMessage::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline uint32_t Message_ImageMessage::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t Message_ImageMessage::height() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.height)
+  return _internal_height();
+}
+inline void Message_ImageMessage::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.height_ = value;
+}
+inline void Message_ImageMessage::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.height)
+}
+
+// optional uint32 width = 7;
+inline bool Message_ImageMessage::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_width() const {
+  return _internal_has_width();
+}
+inline void Message_ImageMessage::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline uint32_t Message_ImageMessage::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t Message_ImageMessage::width() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.width)
+  return _internal_width();
+}
+inline void Message_ImageMessage::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.width_ = value;
+}
+inline void Message_ImageMessage::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.width)
+}
+
+// optional bytes mediaKey = 8;
+inline bool Message_ImageMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_ImageMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_ImageMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKey)
+}
+inline std::string* Message_ImageMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_ImageMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mediaKey)
+}
+
+// optional bytes fileEncSha256 = 9;
+inline bool Message_ImageMessage::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_ImageMessage::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_ImageMessage::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileEncSha256)
+}
+inline std::string* Message_ImageMessage::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileEncSha256)
+}
+
+// repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
+inline int Message_ImageMessage::_internal_interactiveannotations_size() const {
+  return _impl_.interactiveannotations_.size();
+}
+inline int Message_ImageMessage::interactiveannotations_size() const {
+  return _internal_interactiveannotations_size();
+}
+inline void Message_ImageMessage::clear_interactiveannotations() {
+  _impl_.interactiveannotations_.Clear();
+}
+inline ::proto::InteractiveAnnotation* Message_ImageMessage::mutable_interactiveannotations(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.interactiveAnnotations)
+  return _impl_.interactiveannotations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
+Message_ImageMessage::mutable_interactiveannotations() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.interactiveAnnotations)
+  return &_impl_.interactiveannotations_;
+}
+inline const ::proto::InteractiveAnnotation& Message_ImageMessage::_internal_interactiveannotations(int index) const {
+  return _impl_.interactiveannotations_.Get(index);
+}
+inline const ::proto::InteractiveAnnotation& Message_ImageMessage::interactiveannotations(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.interactiveAnnotations)
+  return _internal_interactiveannotations(index);
+}
+inline ::proto::InteractiveAnnotation* Message_ImageMessage::_internal_add_interactiveannotations() {
+  return _impl_.interactiveannotations_.Add();
+}
+inline ::proto::InteractiveAnnotation* Message_ImageMessage::add_interactiveannotations() {
+  ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations();
+  // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.interactiveAnnotations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
+Message_ImageMessage::interactiveannotations() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.interactiveAnnotations)
+  return _impl_.interactiveannotations_;
+}
+
+// optional string directPath = 11;
+inline bool Message_ImageMessage::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_ImageMessage::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_ImageMessage::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.directPath)
+}
+inline std::string* Message_ImageMessage::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.directPath)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_ImageMessage::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.directPath)
+}
+
+// optional int64 mediaKeyTimestamp = 12;
+inline bool Message_ImageMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_ImageMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline int64_t Message_ImageMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_ImageMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_ImageMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_ImageMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKeyTimestamp)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_ImageMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_ImageMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_ImageMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.jpegThumbnail)
+}
+inline std::string* Message_ImageMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_ImageMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_ImageMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ImageMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ImageMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline const ::proto::ContextInfo& Message_ImageMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ImageMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ImageMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ImageMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ImageMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ImageMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ImageMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ImageMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ImageMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.contextInfo)
+}
+
+// optional bytes firstScanSidecar = 18;
+inline bool Message_ImageMessage::_internal_has_firstscansidecar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_firstscansidecar() const {
+  return _internal_has_firstscansidecar();
+}
+inline void Message_ImageMessage::clear_firstscansidecar() {
+  _impl_.firstscansidecar_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& Message_ImageMessage::firstscansidecar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanSidecar)
+  return _internal_firstscansidecar();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_firstscansidecar(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.firstscansidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanSidecar)
+}
+inline std::string* Message_ImageMessage::mutable_firstscansidecar() {
+  std::string* _s = _internal_mutable_firstscansidecar();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.firstScanSidecar)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_firstscansidecar() const {
+  return _impl_.firstscansidecar_.Get();
+}
+inline void Message_ImageMessage::_internal_set_firstscansidecar(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.firstscansidecar_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_firstscansidecar() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.firstscansidecar_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_firstscansidecar() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.firstScanSidecar)
+  if (!_internal_has_firstscansidecar()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.firstscansidecar_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstscansidecar_.IsDefault()) {
+    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_firstscansidecar(std::string* firstscansidecar) {
+  if (firstscansidecar != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.firstscansidecar_.SetAllocated(firstscansidecar, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstscansidecar_.IsDefault()) {
+    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.firstScanSidecar)
+}
+
+// optional uint32 firstScanLength = 19;
+inline bool Message_ImageMessage::_internal_has_firstscanlength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_firstscanlength() const {
+  return _internal_has_firstscanlength();
+}
+inline void Message_ImageMessage::clear_firstscanlength() {
+  _impl_.firstscanlength_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline uint32_t Message_ImageMessage::_internal_firstscanlength() const {
+  return _impl_.firstscanlength_;
+}
+inline uint32_t Message_ImageMessage::firstscanlength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanLength)
+  return _internal_firstscanlength();
+}
+inline void Message_ImageMessage::_internal_set_firstscanlength(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.firstscanlength_ = value;
+}
+inline void Message_ImageMessage::set_firstscanlength(uint32_t value) {
+  _internal_set_firstscanlength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanLength)
+}
+
+// optional uint32 experimentGroupId = 20;
+inline bool Message_ImageMessage::_internal_has_experimentgroupid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_experimentgroupid() const {
+  return _internal_has_experimentgroupid();
+}
+inline void Message_ImageMessage::clear_experimentgroupid() {
+  _impl_.experimentgroupid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline uint32_t Message_ImageMessage::_internal_experimentgroupid() const {
+  return _impl_.experimentgroupid_;
+}
+inline uint32_t Message_ImageMessage::experimentgroupid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.experimentGroupId)
+  return _internal_experimentgroupid();
+}
+inline void Message_ImageMessage::_internal_set_experimentgroupid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.experimentgroupid_ = value;
+}
+inline void Message_ImageMessage::set_experimentgroupid(uint32_t value) {
+  _internal_set_experimentgroupid(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.experimentGroupId)
+}
+
+// optional bytes scansSidecar = 21;
+inline bool Message_ImageMessage::_internal_has_scanssidecar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_scanssidecar() const {
+  return _internal_has_scanssidecar();
+}
+inline void Message_ImageMessage::clear_scanssidecar() {
+  _impl_.scanssidecar_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& Message_ImageMessage::scanssidecar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scansSidecar)
+  return _internal_scanssidecar();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_scanssidecar(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.scanssidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scansSidecar)
+}
+inline std::string* Message_ImageMessage::mutable_scanssidecar() {
+  std::string* _s = _internal_mutable_scanssidecar();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.scansSidecar)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_scanssidecar() const {
+  return _impl_.scanssidecar_.Get();
+}
+inline void Message_ImageMessage::_internal_set_scanssidecar(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.scanssidecar_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_scanssidecar() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.scanssidecar_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_scanssidecar() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.scansSidecar)
+  if (!_internal_has_scanssidecar()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.scanssidecar_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.scanssidecar_.IsDefault()) {
+    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_scanssidecar(std::string* scanssidecar) {
+  if (scanssidecar != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.scanssidecar_.SetAllocated(scanssidecar, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.scanssidecar_.IsDefault()) {
+    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.scansSidecar)
+}
+
+// repeated uint32 scanLengths = 22;
+inline int Message_ImageMessage::_internal_scanlengths_size() const {
+  return _impl_.scanlengths_.size();
+}
+inline int Message_ImageMessage::scanlengths_size() const {
+  return _internal_scanlengths_size();
+}
+inline void Message_ImageMessage::clear_scanlengths() {
+  _impl_.scanlengths_.Clear();
+}
+inline uint32_t Message_ImageMessage::_internal_scanlengths(int index) const {
+  return _impl_.scanlengths_.Get(index);
+}
+inline uint32_t Message_ImageMessage::scanlengths(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scanLengths)
+  return _internal_scanlengths(index);
+}
+inline void Message_ImageMessage::set_scanlengths(int index, uint32_t value) {
+  _impl_.scanlengths_.Set(index, value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scanLengths)
+}
+inline void Message_ImageMessage::_internal_add_scanlengths(uint32_t value) {
+  _impl_.scanlengths_.Add(value);
+}
+inline void Message_ImageMessage::add_scanlengths(uint32_t value) {
+  _internal_add_scanlengths(value);
+  // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.scanLengths)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+Message_ImageMessage::_internal_scanlengths() const {
+  return _impl_.scanlengths_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+Message_ImageMessage::scanlengths() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.scanLengths)
+  return _internal_scanlengths();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+Message_ImageMessage::_internal_mutable_scanlengths() {
+  return &_impl_.scanlengths_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+Message_ImageMessage::mutable_scanlengths() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.scanLengths)
+  return _internal_mutable_scanlengths();
+}
+
+// optional bytes midQualityFileSha256 = 23;
+inline bool Message_ImageMessage::_internal_has_midqualityfilesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_midqualityfilesha256() const {
+  return _internal_has_midqualityfilesha256();
+}
+inline void Message_ImageMessage::clear_midqualityfilesha256() {
+  _impl_.midqualityfilesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& Message_ImageMessage::midqualityfilesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileSha256)
+  return _internal_midqualityfilesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_midqualityfilesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.midqualityfilesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileSha256)
+}
+inline std::string* Message_ImageMessage::mutable_midqualityfilesha256() {
+  std::string* _s = _internal_mutable_midqualityfilesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_midqualityfilesha256() const {
+  return _impl_.midqualityfilesha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_midqualityfilesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.midqualityfilesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_midqualityfilesha256() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.midqualityfilesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_midqualityfilesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileSha256)
+  if (!_internal_has_midqualityfilesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.midqualityfilesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.midqualityfilesha256_.IsDefault()) {
+    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_midqualityfilesha256(std::string* midqualityfilesha256) {
+  if (midqualityfilesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.midqualityfilesha256_.SetAllocated(midqualityfilesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.midqualityfilesha256_.IsDefault()) {
+    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileSha256)
+}
+
+// optional bytes midQualityFileEncSha256 = 24;
+inline bool Message_ImageMessage::_internal_has_midqualityfileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_midqualityfileencsha256() const {
+  return _internal_has_midqualityfileencsha256();
+}
+inline void Message_ImageMessage::clear_midqualityfileencsha256() {
+  _impl_.midqualityfileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& Message_ImageMessage::midqualityfileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileEncSha256)
+  return _internal_midqualityfileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.midqualityfileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileEncSha256)
+}
+inline std::string* Message_ImageMessage::mutable_midqualityfileencsha256() {
+  std::string* _s = _internal_mutable_midqualityfileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileEncSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_midqualityfileencsha256() const {
+  return _impl_.midqualityfileencsha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_midqualityfileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.midqualityfileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_midqualityfileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.midqualityfileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_midqualityfileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileEncSha256)
+  if (!_internal_has_midqualityfileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.midqualityfileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.midqualityfileencsha256_.IsDefault()) {
+    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256) {
+  if (midqualityfileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.midqualityfileencsha256_.SetAllocated(midqualityfileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.midqualityfileencsha256_.IsDefault()) {
+    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileEncSha256)
+}
+
+// optional bool viewOnce = 25;
+inline bool Message_ImageMessage::_internal_has_viewonce() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_viewonce() const {
+  return _internal_has_viewonce();
+}
+inline void Message_ImageMessage::clear_viewonce() {
+  _impl_.viewonce_ = false;
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline bool Message_ImageMessage::_internal_viewonce() const {
+  return _impl_.viewonce_;
+}
+inline bool Message_ImageMessage::viewonce() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.viewOnce)
+  return _internal_viewonce();
+}
+inline void Message_ImageMessage::_internal_set_viewonce(bool value) {
+  _impl_._has_bits_[0] |= 0x00800000u;
+  _impl_.viewonce_ = value;
+}
+inline void Message_ImageMessage::set_viewonce(bool value) {
+  _internal_set_viewonce(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.viewOnce)
+}
+
+// optional string thumbnailDirectPath = 26;
+inline bool Message_ImageMessage::_internal_has_thumbnaildirectpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_thumbnaildirectpath() const {
+  return _internal_has_thumbnaildirectpath();
+}
+inline void Message_ImageMessage::clear_thumbnaildirectpath() {
+  _impl_.thumbnaildirectpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const std::string& Message_ImageMessage::thumbnaildirectpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailDirectPath)
+  return _internal_thumbnaildirectpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00001000u;
+ _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailDirectPath)
+}
+inline std::string* Message_ImageMessage::mutable_thumbnaildirectpath() {
+  std::string* _s = _internal_mutable_thumbnaildirectpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailDirectPath)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_thumbnaildirectpath() const {
+  return _impl_.thumbnaildirectpath_.Get();
+}
+inline void Message_ImageMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_thumbnaildirectpath() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_thumbnaildirectpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailDirectPath)
+  if (!_internal_has_thumbnaildirectpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  auto* p = _impl_.thumbnaildirectpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
+  if (thumbnaildirectpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailDirectPath)
+}
+
+// optional bytes thumbnailSha256 = 27;
+inline bool Message_ImageMessage::_internal_has_thumbnailsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_thumbnailsha256() const {
+  return _internal_has_thumbnailsha256();
+}
+inline void Message_ImageMessage::clear_thumbnailsha256() {
+  _impl_.thumbnailsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const std::string& Message_ImageMessage::thumbnailsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailSha256)
+  return _internal_thumbnailsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00002000u;
+ _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailSha256)
+}
+inline std::string* Message_ImageMessage::mutable_thumbnailsha256() {
+  std::string* _s = _internal_mutable_thumbnailsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_thumbnailsha256() const {
+  return _impl_.thumbnailsha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_thumbnailsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_thumbnailsha256() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_thumbnailsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailSha256)
+  if (!_internal_has_thumbnailsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  auto* p = _impl_.thumbnailsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
+  if (thumbnailsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailSha256)
+}
+
+// optional bytes thumbnailEncSha256 = 28;
+inline bool Message_ImageMessage::_internal_has_thumbnailencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_thumbnailencsha256() const {
+  return _internal_has_thumbnailencsha256();
+}
+inline void Message_ImageMessage::clear_thumbnailencsha256() {
+  _impl_.thumbnailencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline const std::string& Message_ImageMessage::thumbnailencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailEncSha256)
+  return _internal_thumbnailencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00004000u;
+ _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailEncSha256)
+}
+inline std::string* Message_ImageMessage::mutable_thumbnailencsha256() {
+  std::string* _s = _internal_mutable_thumbnailencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailEncSha256)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_thumbnailencsha256() const {
+  return _impl_.thumbnailencsha256_.Get();
+}
+inline void Message_ImageMessage::_internal_set_thumbnailencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_thumbnailencsha256() {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_thumbnailencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailEncSha256)
+  if (!_internal_has_thumbnailencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  auto* p = _impl_.thumbnailencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
+  if (thumbnailencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailEncSha256)
+}
+
+// optional string staticUrl = 29;
+inline bool Message_ImageMessage::_internal_has_staticurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool Message_ImageMessage::has_staticurl() const {
+  return _internal_has_staticurl();
+}
+inline void Message_ImageMessage::clear_staticurl() {
+  _impl_.staticurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline const std::string& Message_ImageMessage::staticurl() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.staticUrl)
+  return _internal_staticurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ImageMessage::set_staticurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00008000u;
+ _impl_.staticurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.staticUrl)
+}
+inline std::string* Message_ImageMessage::mutable_staticurl() {
+  std::string* _s = _internal_mutable_staticurl();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.staticUrl)
+  return _s;
+}
+inline const std::string& Message_ImageMessage::_internal_staticurl() const {
+  return _impl_.staticurl_.Get();
+}
+inline void Message_ImageMessage::_internal_set_staticurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.staticurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::_internal_mutable_staticurl() {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  return _impl_.staticurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ImageMessage::release_staticurl() {
+  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.staticUrl)
+  if (!_internal_has_staticurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  auto* p = _impl_.staticurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.staticurl_.IsDefault()) {
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ImageMessage::set_allocated_staticurl(std::string* staticurl) {
+  if (staticurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.staticurl_.IsDefault()) {
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.staticUrl)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InitialSecurityNotificationSettingSync
+
+// optional bool securityNotificationEnabled = 1;
+inline bool Message_InitialSecurityNotificationSettingSync::_internal_has_securitynotificationenabled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InitialSecurityNotificationSettingSync::has_securitynotificationenabled() const {
+  return _internal_has_securitynotificationenabled();
+}
+inline void Message_InitialSecurityNotificationSettingSync::clear_securitynotificationenabled() {
+  _impl_.securitynotificationenabled_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool Message_InitialSecurityNotificationSettingSync::_internal_securitynotificationenabled() const {
+  return _impl_.securitynotificationenabled_;
+}
+inline bool Message_InitialSecurityNotificationSettingSync::securitynotificationenabled() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled)
+  return _internal_securitynotificationenabled();
+}
+inline void Message_InitialSecurityNotificationSettingSync::_internal_set_securitynotificationenabled(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.securitynotificationenabled_ = value;
+}
+inline void Message_InitialSecurityNotificationSettingSync::set_securitynotificationenabled(bool value) {
+  _internal_set_securitynotificationenabled(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_Body
+
+// optional string text = 1;
+inline bool Message_InteractiveMessage_Body::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_Body::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_InteractiveMessage_Body::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_Body::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Body.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_Body::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Body.text)
+}
+inline std::string* Message_InteractiveMessage_Body::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Body.text)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_Body::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Message_InteractiveMessage_Body::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Body::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Body::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Body.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_Body::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Body.text)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_CollectionMessage
+
+// optional string bizJid = 1;
+inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_bizjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_CollectionMessage::has_bizjid() const {
+  return _internal_has_bizjid();
+}
+inline void Message_InteractiveMessage_CollectionMessage::clear_bizjid() {
+  _impl_.bizjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_CollectionMessage::bizjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
+  return _internal_bizjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_CollectionMessage::set_bizjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.bizjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_bizjid() {
+  std::string* _s = _internal_mutable_bizjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_bizjid() const {
+  return _impl_.bizjid_.Get();
+}
+inline void Message_InteractiveMessage_CollectionMessage::_internal_set_bizjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.bizjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_bizjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.bizjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::release_bizjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
+  if (!_internal_has_bizjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.bizjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bizjid_.IsDefault()) {
+    _impl_.bizjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_CollectionMessage::set_allocated_bizjid(std::string* bizjid) {
+  if (bizjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.bizjid_.SetAllocated(bizjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bizjid_.IsDefault()) {
+    _impl_.bizjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
+}
+
+// optional string id = 2;
+inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_CollectionMessage::has_id() const {
+  return _internal_has_id();
+}
+inline void Message_InteractiveMessage_CollectionMessage::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_InteractiveMessage_CollectionMessage::id() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_CollectionMessage::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.id)
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.id)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void Message_InteractiveMessage_CollectionMessage::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_CollectionMessage::release_id() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_CollectionMessage::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.id)
+}
+
+// optional int32 messageVersion = 3;
+inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_messageversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_CollectionMessage::has_messageversion() const {
+  return _internal_has_messageversion();
+}
+inline void Message_InteractiveMessage_CollectionMessage::clear_messageversion() {
+  _impl_.messageversion_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t Message_InteractiveMessage_CollectionMessage::_internal_messageversion() const {
+  return _impl_.messageversion_;
+}
+inline int32_t Message_InteractiveMessage_CollectionMessage::messageversion() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.messageVersion)
+  return _internal_messageversion();
+}
+inline void Message_InteractiveMessage_CollectionMessage::_internal_set_messageversion(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.messageversion_ = value;
+}
+inline void Message_InteractiveMessage_CollectionMessage::set_messageversion(int32_t value) {
+  _internal_set_messageversion(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.messageVersion)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_Footer
+
+// optional string text = 1;
+inline bool Message_InteractiveMessage_Footer::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_Footer::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_InteractiveMessage_Footer::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_Footer::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Footer.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_Footer::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Footer.text)
+}
+inline std::string* Message_InteractiveMessage_Footer::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Footer.text)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_Footer::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Message_InteractiveMessage_Footer::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Footer::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Footer::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Footer.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_Footer::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Footer.text)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_Header
+
+// optional string title = 1;
+inline bool Message_InteractiveMessage_Header::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_Header::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_InteractiveMessage_Header::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_Header::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_Header::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.title)
+}
+inline std::string* Message_InteractiveMessage_Header::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.title)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_Header::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_InteractiveMessage_Header::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_Header::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.title)
+}
+
+// optional string subtitle = 2;
+inline bool Message_InteractiveMessage_Header::_internal_has_subtitle() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_Header::has_subtitle() const {
+  return _internal_has_subtitle();
+}
+inline void Message_InteractiveMessage_Header::clear_subtitle() {
+  _impl_.subtitle_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_InteractiveMessage_Header::subtitle() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.subtitle)
+  return _internal_subtitle();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_Header::set_subtitle(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.subtitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.subtitle)
+}
+inline std::string* Message_InteractiveMessage_Header::mutable_subtitle() {
+  std::string* _s = _internal_mutable_subtitle();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.subtitle)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_Header::_internal_subtitle() const {
+  return _impl_.subtitle_.Get();
+}
+inline void Message_InteractiveMessage_Header::_internal_set_subtitle(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.subtitle_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::_internal_mutable_subtitle() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.subtitle_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::release_subtitle() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.subtitle)
+  if (!_internal_has_subtitle()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.subtitle_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.subtitle_.IsDefault()) {
+    _impl_.subtitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_Header::set_allocated_subtitle(std::string* subtitle) {
+  if (subtitle != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.subtitle_.SetAllocated(subtitle, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.subtitle_.IsDefault()) {
+    _impl_.subtitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.subtitle)
+}
+
+// optional bool hasMediaAttachment = 5;
+inline bool Message_InteractiveMessage_Header::_internal_has_hasmediaattachment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_Header::has_hasmediaattachment() const {
+  return _internal_has_hasmediaattachment();
+}
+inline void Message_InteractiveMessage_Header::clear_hasmediaattachment() {
+  _impl_.hasmediaattachment_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool Message_InteractiveMessage_Header::_internal_hasmediaattachment() const {
+  return _impl_.hasmediaattachment_;
+}
+inline bool Message_InteractiveMessage_Header::hasmediaattachment() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.hasMediaAttachment)
+  return _internal_hasmediaattachment();
+}
+inline void Message_InteractiveMessage_Header::_internal_set_hasmediaattachment(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.hasmediaattachment_ = value;
+}
+inline void Message_InteractiveMessage_Header::set_hasmediaattachment(bool value) {
+  _internal_set_hasmediaattachment(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.hasMediaAttachment)
+}
+
+// .proto.Message.DocumentMessage documentMessage = 3;
+inline bool Message_InteractiveMessage_Header::_internal_has_documentmessage() const {
+  return media_case() == kDocumentMessage;
+}
+inline bool Message_InteractiveMessage_Header::has_documentmessage() const {
+  return _internal_has_documentmessage();
+}
+inline void Message_InteractiveMessage_Header::set_has_documentmessage() {
+  _impl_._oneof_case_[0] = kDocumentMessage;
+}
+inline void Message_InteractiveMessage_Header::clear_documentmessage() {
+  if (_internal_has_documentmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.media_.documentmessage_;
+    }
+    clear_has_media();
+  }
+}
+inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::release_documentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_media();
+    ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.media_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::_internal_documentmessage() const {
+  return _internal_has_documentmessage()
+      ? *_impl_.media_.documentmessage_
+      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
+}
+inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::documentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.documentMessage)
+  return _internal_documentmessage();
+}
+inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::unsafe_arena_release_documentmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_media();
+    ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_;
+    _impl_.media_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  clear_media();
+  if (documentmessage) {
+    set_has_documentmessage();
+    _impl_.media_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage)
+}
+inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::_internal_mutable_documentmessage() {
+  if (!_internal_has_documentmessage()) {
+    clear_media();
+    set_has_documentmessage();
+    _impl_.media_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
+  }
+  return _impl_.media_.documentmessage_;
+}
+inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::mutable_documentmessage() {
+  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.documentMessage)
+  return _msg;
+}
+
+// .proto.Message.ImageMessage imageMessage = 4;
+inline bool Message_InteractiveMessage_Header::_internal_has_imagemessage() const {
+  return media_case() == kImageMessage;
+}
+inline bool Message_InteractiveMessage_Header::has_imagemessage() const {
+  return _internal_has_imagemessage();
+}
+inline void Message_InteractiveMessage_Header::set_has_imagemessage() {
+  _impl_._oneof_case_[0] = kImageMessage;
+}
+inline void Message_InteractiveMessage_Header::clear_imagemessage() {
+  if (_internal_has_imagemessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.media_.imagemessage_;
+    }
+    clear_has_media();
+  }
+}
+inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::release_imagemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_media();
+    ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.media_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::_internal_imagemessage() const {
+  return _internal_has_imagemessage()
+      ? *_impl_.media_.imagemessage_
+      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::imagemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.imageMessage)
+  return _internal_imagemessage();
+}
+inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::unsafe_arena_release_imagemessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_media();
+    ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_;
+    _impl_.media_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  clear_media();
+  if (imagemessage) {
+    set_has_imagemessage();
+    _impl_.media_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage)
+}
+inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::_internal_mutable_imagemessage() {
+  if (!_internal_has_imagemessage()) {
+    clear_media();
+    set_has_imagemessage();
+    _impl_.media_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
+  }
+  return _impl_.media_.imagemessage_;
+}
+inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::mutable_imagemessage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.imageMessage)
+  return _msg;
+}
+
+// bytes jpegThumbnail = 6;
+inline bool Message_InteractiveMessage_Header::_internal_has_jpegthumbnail() const {
+  return media_case() == kJpegThumbnail;
+}
+inline bool Message_InteractiveMessage_Header::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_InteractiveMessage_Header::set_has_jpegthumbnail() {
+  _impl_._oneof_case_[0] = kJpegThumbnail;
+}
+inline void Message_InteractiveMessage_Header::clear_jpegthumbnail() {
+  if (_internal_has_jpegthumbnail()) {
+    _impl_.media_.jpegthumbnail_.Destroy();
+    clear_has_media();
+  }
+}
+inline const std::string& Message_InteractiveMessage_Header::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Message_InteractiveMessage_Header::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_jpegthumbnail()) {
+    clear_media();
+    set_has_jpegthumbnail();
+    _impl_.media_.jpegthumbnail_.InitDefault();
+  }
+  _impl_.media_.jpegthumbnail_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.jpegThumbnail)
+}
+inline std::string* Message_InteractiveMessage_Header::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_Header::_internal_jpegthumbnail() const {
+  if (_internal_has_jpegthumbnail()) {
+    return _impl_.media_.jpegthumbnail_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Message_InteractiveMessage_Header::_internal_set_jpegthumbnail(const std::string& value) {
+  if (!_internal_has_jpegthumbnail()) {
+    clear_media();
+    set_has_jpegthumbnail();
+    _impl_.media_.jpegthumbnail_.InitDefault();
+  }
+  _impl_.media_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::_internal_mutable_jpegthumbnail() {
+  if (!_internal_has_jpegthumbnail()) {
+    clear_media();
+    set_has_jpegthumbnail();
+    _impl_.media_.jpegthumbnail_.InitDefault();
+  }
+  return _impl_.media_.jpegthumbnail_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_Header::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.jpegThumbnail)
+  if (_internal_has_jpegthumbnail()) {
+    clear_has_media();
+    return _impl_.media_.jpegthumbnail_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage_Header::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (has_media()) {
+    clear_media();
+  }
+  if (jpegthumbnail != nullptr) {
+    set_has_jpegthumbnail();
+    _impl_.media_.jpegthumbnail_.InitAllocated(jpegthumbnail, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.jpegThumbnail)
+}
+
+// .proto.Message.VideoMessage videoMessage = 7;
+inline bool Message_InteractiveMessage_Header::_internal_has_videomessage() const {
+  return media_case() == kVideoMessage;
+}
+inline bool Message_InteractiveMessage_Header::has_videomessage() const {
+  return _internal_has_videomessage();
+}
+inline void Message_InteractiveMessage_Header::set_has_videomessage() {
+  _impl_._oneof_case_[0] = kVideoMessage;
+}
+inline void Message_InteractiveMessage_Header::clear_videomessage() {
+  if (_internal_has_videomessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.media_.videomessage_;
+    }
+    clear_has_media();
+  }
+}
+inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::release_videomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_media();
+    ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.media_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::_internal_videomessage() const {
+  return _internal_has_videomessage()
+      ? *_impl_.media_.videomessage_
+      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
+}
+inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::videomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.videoMessage)
+  return _internal_videomessage();
+}
+inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::unsafe_arena_release_videomessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_media();
+    ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_;
+    _impl_.media_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  clear_media();
+  if (videomessage) {
+    set_has_videomessage();
+    _impl_.media_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage)
+}
+inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::_internal_mutable_videomessage() {
+  if (!_internal_has_videomessage()) {
+    clear_media();
+    set_has_videomessage();
+    _impl_.media_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
+  }
+  return _impl_.media_.videomessage_;
+}
+inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::mutable_videomessage() {
+  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.videoMessage)
+  return _msg;
+}
+
+inline bool Message_InteractiveMessage_Header::has_media() const {
+  return media_case() != MEDIA_NOT_SET;
+}
+inline void Message_InteractiveMessage_Header::clear_has_media() {
+  _impl_._oneof_case_[0] = MEDIA_NOT_SET;
+}
+inline Message_InteractiveMessage_Header::MediaCase Message_InteractiveMessage_Header::media_case() const {
+  return Message_InteractiveMessage_Header::MediaCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton
+
+// optional string name = 1;
+inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_name() const {
+  return _internal_has_name();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::name() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
+}
+
+// optional string buttonParamsJson = 2;
+inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_buttonparamsjson() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_buttonparamsjson() const {
+  return _internal_has_buttonparamsjson();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_buttonparamsjson() {
+  _impl_.buttonparamsjson_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::buttonparamsjson() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
+  return _internal_buttonparamsjson();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_buttonparamsjson(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.buttonparamsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_buttonparamsjson() {
+  std::string* _s = _internal_mutable_buttonparamsjson();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_buttonparamsjson() const {
+  return _impl_.buttonparamsjson_.Get();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_buttonparamsjson(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.buttonparamsjson_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_buttonparamsjson() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.buttonparamsjson_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_buttonparamsjson() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
+  if (!_internal_has_buttonparamsjson()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.buttonparamsjson_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttonparamsjson_.IsDefault()) {
+    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_buttonparamsjson(std::string* buttonparamsjson) {
+  if (buttonparamsjson != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.buttonparamsjson_.SetAllocated(buttonparamsjson, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttonparamsjson_.IsDefault()) {
+    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_NativeFlowMessage
+
+// repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
+inline int Message_InteractiveMessage_NativeFlowMessage::_internal_buttons_size() const {
+  return _impl_.buttons_.size();
+}
+inline int Message_InteractiveMessage_NativeFlowMessage::buttons_size() const {
+  return _internal_buttons_size();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::clear_buttons() {
+  _impl_.buttons_.Clear();
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::mutable_buttons(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
+  return _impl_.buttons_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >*
+Message_InteractiveMessage_NativeFlowMessage::mutable_buttons() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
+  return &_impl_.buttons_;
+}
+inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::_internal_buttons(int index) const {
+  return _impl_.buttons_.Get(index);
+}
+inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::buttons(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
+  return _internal_buttons(index);
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::_internal_add_buttons() {
+  return _impl_.buttons_.Add();
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::add_buttons() {
+  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _add = _internal_add_buttons();
+  // @@protoc_insertion_point(field_add:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >&
+Message_InteractiveMessage_NativeFlowMessage::buttons() const {
+  // @@protoc_insertion_point(field_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
+  return _impl_.buttons_;
+}
+
+// optional string messageParamsJson = 2;
+inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageparamsjson() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageparamsjson() const {
+  return _internal_has_messageparamsjson();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageparamsjson() {
+  _impl_.messageparamsjson_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage::messageparamsjson() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
+  return _internal_messageparamsjson();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_NativeFlowMessage::set_messageparamsjson(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.messageparamsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage::mutable_messageparamsjson() {
+  std::string* _s = _internal_mutable_messageparamsjson();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_NativeFlowMessage::_internal_messageparamsjson() const {
+  return _impl_.messageparamsjson_.Get();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageparamsjson(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.messageparamsjson_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage::_internal_mutable_messageparamsjson() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.messageparamsjson_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_NativeFlowMessage::release_messageparamsjson() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
+  if (!_internal_has_messageparamsjson()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.messageparamsjson_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messageparamsjson_.IsDefault()) {
+    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::set_allocated_messageparamsjson(std::string* messageparamsjson) {
+  if (messageparamsjson != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messageparamsjson_.SetAllocated(messageparamsjson, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messageparamsjson_.IsDefault()) {
+    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
+}
+
+// optional int32 messageVersion = 3;
+inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageversion() const {
+  return _internal_has_messageversion();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageversion() {
+  _impl_.messageversion_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t Message_InteractiveMessage_NativeFlowMessage::_internal_messageversion() const {
+  return _impl_.messageversion_;
+}
+inline int32_t Message_InteractiveMessage_NativeFlowMessage::messageversion() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion)
+  return _internal_messageversion();
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageversion(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.messageversion_ = value;
+}
+inline void Message_InteractiveMessage_NativeFlowMessage::set_messageversion(int32_t value) {
+  _internal_set_messageversion(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage_ShopMessage
+
+// optional string id = 1;
+inline bool Message_InteractiveMessage_ShopMessage::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_ShopMessage::has_id() const {
+  return _internal_has_id();
+}
+inline void Message_InteractiveMessage_ShopMessage::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveMessage_ShopMessage::id() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveMessage_ShopMessage::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.id)
+}
+inline std::string* Message_InteractiveMessage_ShopMessage::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.ShopMessage.id)
+  return _s;
+}
+inline const std::string& Message_InteractiveMessage_ShopMessage::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void Message_InteractiveMessage_ShopMessage::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_ShopMessage::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveMessage_ShopMessage::release_id() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.ShopMessage.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveMessage_ShopMessage::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.ShopMessage.id)
+}
+
+// optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
+inline bool Message_InteractiveMessage_ShopMessage::_internal_has_surface() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_ShopMessage::has_surface() const {
+  return _internal_has_surface();
+}
+inline void Message_InteractiveMessage_ShopMessage::clear_surface() {
+  _impl_.surface_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::_internal_surface() const {
+  return static_cast< ::proto::Message_InteractiveMessage_ShopMessage_Surface >(_impl_.surface_);
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::surface() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.surface)
+  return _internal_surface();
+}
+inline void Message_InteractiveMessage_ShopMessage::_internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) {
+  assert(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.surface_ = value;
+}
+inline void Message_InteractiveMessage_ShopMessage::set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) {
+  _internal_set_surface(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.surface)
+}
+
+// optional int32 messageVersion = 3;
+inline bool Message_InteractiveMessage_ShopMessage::_internal_has_messageversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_InteractiveMessage_ShopMessage::has_messageversion() const {
+  return _internal_has_messageversion();
+}
+inline void Message_InteractiveMessage_ShopMessage::clear_messageversion() {
+  _impl_.messageversion_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t Message_InteractiveMessage_ShopMessage::_internal_messageversion() const {
+  return _impl_.messageversion_;
+}
+inline int32_t Message_InteractiveMessage_ShopMessage::messageversion() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.messageVersion)
+  return _internal_messageversion();
+}
+inline void Message_InteractiveMessage_ShopMessage::_internal_set_messageversion(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.messageversion_ = value;
+}
+inline void Message_InteractiveMessage_ShopMessage::set_messageversion(int32_t value) {
+  _internal_set_messageversion(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.messageVersion)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveMessage
+
+// optional .proto.Message.InteractiveMessage.Header header = 1;
+inline bool Message_InteractiveMessage::_internal_has_header() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveMessage::has_header() const {
+  return _internal_has_header();
+}
+inline void Message_InteractiveMessage::clear_header() {
+  if (_impl_.header_ != nullptr) _impl_.header_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::_internal_header() const {
+  const ::proto::Message_InteractiveMessage_Header* p = _impl_.header_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Header&>(
+      ::proto::_Message_InteractiveMessage_Header_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::header() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.header)
+  return _internal_header();
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_header(
+    ::proto::Message_InteractiveMessage_Header* header) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
+  }
+  _impl_.header_ = header;
+  if (header) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.header)
+}
+inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::release_header() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_;
+  _impl_.header_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::unsafe_arena_release_header() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.header)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_;
+  _impl_.header_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::_internal_mutable_header() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.header_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(GetArenaForAllocation());
+    _impl_.header_ = p;
+  }
+  return _impl_.header_;
+}
+inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::mutable_header() {
+  ::proto::Message_InteractiveMessage_Header* _msg = _internal_mutable_header();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.header)
+  return _msg;
+}
+inline void Message_InteractiveMessage::set_allocated_header(::proto::Message_InteractiveMessage_Header* header) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.header_;
+  }
+  if (header) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(header);
+    if (message_arena != submessage_arena) {
+      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, header, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.header_ = header;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.header)
+}
+
+// optional .proto.Message.InteractiveMessage.Body body = 2;
+inline bool Message_InteractiveMessage::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveMessage::has_body() const {
+  return _internal_has_body();
+}
+inline void Message_InteractiveMessage::clear_body() {
+  if (_impl_.body_ != nullptr) _impl_.body_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::_internal_body() const {
+  const ::proto::Message_InteractiveMessage_Body* p = _impl_.body_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Body&>(
+      ::proto::_Message_InteractiveMessage_Body_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::body() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.body)
+  return _internal_body();
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_body(
+    ::proto::Message_InteractiveMessage_Body* body) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_);
+  }
+  _impl_.body_ = body;
+  if (body) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.body)
+}
+inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::release_body() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_;
+  _impl_.body_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::unsafe_arena_release_body() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.body)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_;
+  _impl_.body_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.body_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(GetArenaForAllocation());
+    _impl_.body_ = p;
+  }
+  return _impl_.body_;
+}
+inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::mutable_body() {
+  ::proto::Message_InteractiveMessage_Body* _msg = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.body)
+  return _msg;
+}
+inline void Message_InteractiveMessage::set_allocated_body(::proto::Message_InteractiveMessage_Body* body) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.body_;
+  }
+  if (body) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body);
+    if (message_arena != submessage_arena) {
+      body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, body, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.body_ = body;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.body)
+}
+
+// optional .proto.Message.InteractiveMessage.Footer footer = 3;
+inline bool Message_InteractiveMessage::_internal_has_footer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveMessage::has_footer() const {
+  return _internal_has_footer();
+}
+inline void Message_InteractiveMessage::clear_footer() {
+  if (_impl_.footer_ != nullptr) _impl_.footer_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::_internal_footer() const {
+  const ::proto::Message_InteractiveMessage_Footer* p = _impl_.footer_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Footer&>(
+      ::proto::_Message_InteractiveMessage_Footer_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::footer() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.footer)
+  return _internal_footer();
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_footer(
+    ::proto::Message_InteractiveMessage_Footer* footer) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_);
+  }
+  _impl_.footer_ = footer;
+  if (footer) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.footer)
+}
+inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::release_footer() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_;
+  _impl_.footer_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::unsafe_arena_release_footer() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.footer)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_;
+  _impl_.footer_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::_internal_mutable_footer() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.footer_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(GetArenaForAllocation());
+    _impl_.footer_ = p;
+  }
+  return _impl_.footer_;
+}
+inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::mutable_footer() {
+  ::proto::Message_InteractiveMessage_Footer* _msg = _internal_mutable_footer();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.footer)
+  return _msg;
+}
+inline void Message_InteractiveMessage::set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.footer_;
+  }
+  if (footer) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer);
+    if (message_arena != submessage_arena) {
+      footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, footer, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.footer_ = footer;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.footer)
+}
+
+// optional .proto.ContextInfo contextInfo = 15;
+inline bool Message_InteractiveMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_InteractiveMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::ContextInfo& Message_InteractiveMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_InteractiveMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_InteractiveMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_InteractiveMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_InteractiveMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_InteractiveMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.contextInfo)
+  return _msg;
+}
+inline void Message_InteractiveMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.contextInfo)
+}
+
+// .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
+inline bool Message_InteractiveMessage::_internal_has_shopstorefrontmessage() const {
+  return interactiveMessage_case() == kShopStorefrontMessage;
+}
+inline bool Message_InteractiveMessage::has_shopstorefrontmessage() const {
+  return _internal_has_shopstorefrontmessage();
+}
+inline void Message_InteractiveMessage::set_has_shopstorefrontmessage() {
+  _impl_._oneof_case_[0] = kShopStorefrontMessage;
+}
+inline void Message_InteractiveMessage::clear_shopstorefrontmessage() {
+  if (_internal_has_shopstorefrontmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.interactiveMessage_.shopstorefrontmessage_;
+    }
+    clear_has_interactiveMessage();
+  }
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::release_shopstorefrontmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.shopStorefrontMessage)
+  if (_internal_has_shopstorefrontmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::_internal_shopstorefrontmessage() const {
+  return _internal_has_shopstorefrontmessage()
+      ? *_impl_.interactiveMessage_.shopstorefrontmessage_
+      : reinterpret_cast< ::proto::Message_InteractiveMessage_ShopMessage&>(::proto::_Message_InteractiveMessage_ShopMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::shopstorefrontmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.shopStorefrontMessage)
+  return _internal_shopstorefrontmessage();
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::unsafe_arena_release_shopstorefrontmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.shopStorefrontMessage)
+  if (_internal_has_shopstorefrontmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_;
+    _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) {
+  clear_interactiveMessage();
+  if (shopstorefrontmessage) {
+    set_has_shopstorefrontmessage();
+    _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage)
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::_internal_mutable_shopstorefrontmessage() {
+  if (!_internal_has_shopstorefrontmessage()) {
+    clear_interactiveMessage();
+    set_has_shopstorefrontmessage();
+    _impl_.interactiveMessage_.shopstorefrontmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(GetArenaForAllocation());
+  }
+  return _impl_.interactiveMessage_.shopstorefrontmessage_;
+}
+inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::mutable_shopstorefrontmessage() {
+  ::proto::Message_InteractiveMessage_ShopMessage* _msg = _internal_mutable_shopstorefrontmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.shopStorefrontMessage)
+  return _msg;
+}
+
+// .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
+inline bool Message_InteractiveMessage::_internal_has_collectionmessage() const {
+  return interactiveMessage_case() == kCollectionMessage;
+}
+inline bool Message_InteractiveMessage::has_collectionmessage() const {
+  return _internal_has_collectionmessage();
+}
+inline void Message_InteractiveMessage::set_has_collectionmessage() {
+  _impl_._oneof_case_[0] = kCollectionMessage;
+}
+inline void Message_InteractiveMessage::clear_collectionmessage() {
+  if (_internal_has_collectionmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.interactiveMessage_.collectionmessage_;
+    }
+    clear_has_interactiveMessage();
+  }
+}
+inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::release_collectionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.collectionMessage)
+  if (_internal_has_collectionmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.interactiveMessage_.collectionmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::_internal_collectionmessage() const {
+  return _internal_has_collectionmessage()
+      ? *_impl_.interactiveMessage_.collectionmessage_
+      : reinterpret_cast< ::proto::Message_InteractiveMessage_CollectionMessage&>(::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::collectionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.collectionMessage)
+  return _internal_collectionmessage();
+}
+inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::unsafe_arena_release_collectionmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.collectionMessage)
+  if (_internal_has_collectionmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_;
+    _impl_.interactiveMessage_.collectionmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) {
+  clear_interactiveMessage();
+  if (collectionmessage) {
+    set_has_collectionmessage();
+    _impl_.interactiveMessage_.collectionmessage_ = collectionmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.collectionMessage)
+}
+inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::_internal_mutable_collectionmessage() {
+  if (!_internal_has_collectionmessage()) {
+    clear_interactiveMessage();
+    set_has_collectionmessage();
+    _impl_.interactiveMessage_.collectionmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(GetArenaForAllocation());
+  }
+  return _impl_.interactiveMessage_.collectionmessage_;
+}
+inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::mutable_collectionmessage() {
+  ::proto::Message_InteractiveMessage_CollectionMessage* _msg = _internal_mutable_collectionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.collectionMessage)
+  return _msg;
+}
+
+// .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
+inline bool Message_InteractiveMessage::_internal_has_nativeflowmessage() const {
+  return interactiveMessage_case() == kNativeFlowMessage;
+}
+inline bool Message_InteractiveMessage::has_nativeflowmessage() const {
+  return _internal_has_nativeflowmessage();
+}
+inline void Message_InteractiveMessage::set_has_nativeflowmessage() {
+  _impl_._oneof_case_[0] = kNativeFlowMessage;
+}
+inline void Message_InteractiveMessage::clear_nativeflowmessage() {
+  if (_internal_has_nativeflowmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.interactiveMessage_.nativeflowmessage_;
+    }
+    clear_has_interactiveMessage();
+  }
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::release_nativeflowmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.nativeFlowMessage)
+  if (_internal_has_nativeflowmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.interactiveMessage_.nativeflowmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::_internal_nativeflowmessage() const {
+  return _internal_has_nativeflowmessage()
+      ? *_impl_.interactiveMessage_.nativeflowmessage_
+      : reinterpret_cast< ::proto::Message_InteractiveMessage_NativeFlowMessage&>(::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::nativeflowmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.nativeFlowMessage)
+  return _internal_nativeflowmessage();
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::unsafe_arena_release_nativeflowmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.nativeFlowMessage)
+  if (_internal_has_nativeflowmessage()) {
+    clear_has_interactiveMessage();
+    ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_;
+    _impl_.interactiveMessage_.nativeflowmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveMessage::unsafe_arena_set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) {
+  clear_interactiveMessage();
+  if (nativeflowmessage) {
+    set_has_nativeflowmessage();
+    _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage)
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::_internal_mutable_nativeflowmessage() {
+  if (!_internal_has_nativeflowmessage()) {
+    clear_interactiveMessage();
+    set_has_nativeflowmessage();
+    _impl_.interactiveMessage_.nativeflowmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(GetArenaForAllocation());
+  }
+  return _impl_.interactiveMessage_.nativeflowmessage_;
+}
+inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::mutable_nativeflowmessage() {
+  ::proto::Message_InteractiveMessage_NativeFlowMessage* _msg = _internal_mutable_nativeflowmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.nativeFlowMessage)
+  return _msg;
+}
+
+inline bool Message_InteractiveMessage::has_interactiveMessage() const {
+  return interactiveMessage_case() != INTERACTIVEMESSAGE_NOT_SET;
+}
+inline void Message_InteractiveMessage::clear_has_interactiveMessage() {
+  _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET;
+}
+inline Message_InteractiveMessage::InteractiveMessageCase Message_InteractiveMessage::interactiveMessage_case() const {
+  return Message_InteractiveMessage::InteractiveMessageCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_InteractiveResponseMessage_Body
+
+// optional string text = 1;
+inline bool Message_InteractiveResponseMessage_Body::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveResponseMessage_Body::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_InteractiveResponseMessage_Body::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveResponseMessage_Body::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.Body.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveResponseMessage_Body::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.Body.text)
+}
+inline std::string* Message_InteractiveResponseMessage_Body::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.Body.text)
+  return _s;
+}
+inline const std::string& Message_InteractiveResponseMessage_Body::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Message_InteractiveResponseMessage_Body::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_Body::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_Body::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.Body.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveResponseMessage_Body::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.Body.text)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveResponseMessage_NativeFlowResponseMessage
+
+// optional string name = 1;
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_name() const {
+  return _internal_has_name();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::name() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
+  return _s;
+}
+inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
+}
+
+// optional string paramsJson = 2;
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_paramsjson() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_paramsjson() const {
+  return _internal_has_paramsjson();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_paramsjson() {
+  _impl_.paramsjson_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::paramsjson() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
+  return _internal_paramsjson();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_paramsjson(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.paramsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_paramsjson() {
+  std::string* _s = _internal_mutable_paramsjson();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
+  return _s;
+}
+inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_paramsjson() const {
+  return _impl_.paramsjson_.Get();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_paramsjson(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.paramsjson_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_paramsjson() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.paramsjson_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_paramsjson() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
+  if (!_internal_has_paramsjson()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.paramsjson_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paramsjson_.IsDefault()) {
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_paramsjson(std::string* paramsjson) {
+  if (paramsjson != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paramsjson_.IsDefault()) {
+    _impl_.paramsjson_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
+}
+
+// optional int32 version = 3;
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_version() const {
+  return _internal_has_version();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_version() {
+  _impl_.version_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_version() const {
+  return _impl_.version_;
+}
+inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::version() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version)
+  return _internal_version();
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_version(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.version_ = value;
+}
+inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_version(int32_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version)
+}
+
+// -------------------------------------------------------------------
+
+// Message_InteractiveResponseMessage
+
+// optional .proto.Message.InteractiveResponseMessage.Body body = 1;
+inline bool Message_InteractiveResponseMessage::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveResponseMessage::has_body() const {
+  return _internal_has_body();
+}
+inline void Message_InteractiveResponseMessage::clear_body() {
+  if (_impl_.body_ != nullptr) _impl_.body_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::_internal_body() const {
+  const ::proto::Message_InteractiveResponseMessage_Body* p = _impl_.body_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveResponseMessage_Body&>(
+      ::proto::_Message_InteractiveResponseMessage_Body_default_instance_);
+}
+inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::body() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.body)
+  return _internal_body();
+}
+inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_body(
+    ::proto::Message_InteractiveResponseMessage_Body* body) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_);
+  }
+  _impl_.body_ = body;
+  if (body) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.body)
+}
+inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::release_body() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_;
+  _impl_.body_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::unsafe_arena_release_body() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.body)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_;
+  _impl_.body_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.body_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(GetArenaForAllocation());
+    _impl_.body_ = p;
+  }
+  return _impl_.body_;
+}
+inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::mutable_body() {
+  ::proto::Message_InteractiveResponseMessage_Body* _msg = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.body)
+  return _msg;
+}
+inline void Message_InteractiveResponseMessage::set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.body_;
+  }
+  if (body) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body);
+    if (message_arena != submessage_arena) {
+      body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, body, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.body_ = body;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.body)
+}
+
+// optional .proto.ContextInfo contextInfo = 15;
+inline bool Message_InteractiveResponseMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_InteractiveResponseMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_InteractiveResponseMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_InteractiveResponseMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_InteractiveResponseMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_InteractiveResponseMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_InteractiveResponseMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.contextInfo)
+  return _msg;
+}
+inline void Message_InteractiveResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo)
+}
+
+// .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+inline bool Message_InteractiveResponseMessage::_internal_has_nativeflowresponsemessage() const {
+  return interactiveResponseMessage_case() == kNativeFlowResponseMessage;
+}
+inline bool Message_InteractiveResponseMessage::has_nativeflowresponsemessage() const {
+  return _internal_has_nativeflowresponsemessage();
+}
+inline void Message_InteractiveResponseMessage::set_has_nativeflowresponsemessage() {
+  _impl_._oneof_case_[0] = kNativeFlowResponseMessage;
+}
+inline void Message_InteractiveResponseMessage::clear_nativeflowresponsemessage() {
+  if (_internal_has_nativeflowresponsemessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+    }
+    clear_has_interactiveResponseMessage();
+  }
+}
+inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::release_nativeflowresponsemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+  if (_internal_has_nativeflowresponsemessage()) {
+    clear_has_interactiveResponseMessage();
+    ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::_internal_nativeflowresponsemessage() const {
+  return _internal_has_nativeflowresponsemessage()
+      ? *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_
+      : reinterpret_cast< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage&>(::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::nativeflowresponsemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+  return _internal_nativeflowresponsemessage();
+}
+inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::unsafe_arena_release_nativeflowresponsemessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+  if (_internal_has_nativeflowresponsemessage()) {
+    clear_has_interactiveResponseMessage();
+    ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) {
+  clear_interactiveResponseMessage();
+  if (nativeflowresponsemessage) {
+    set_has_nativeflowresponsemessage();
+    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+}
+inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::_internal_mutable_nativeflowresponsemessage() {
+  if (!_internal_has_nativeflowresponsemessage()) {
+    clear_interactiveResponseMessage();
+    set_has_nativeflowresponsemessage();
+    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(GetArenaForAllocation());
+  }
+  return _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
+}
+inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::mutable_nativeflowresponsemessage() {
+  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _msg = _internal_mutable_nativeflowresponsemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
+  return _msg;
+}
+
+inline bool Message_InteractiveResponseMessage::has_interactiveResponseMessage() const {
+  return interactiveResponseMessage_case() != INTERACTIVERESPONSEMESSAGE_NOT_SET;
+}
+inline void Message_InteractiveResponseMessage::clear_has_interactiveResponseMessage() {
+  _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET;
+}
+inline Message_InteractiveResponseMessage::InteractiveResponseMessageCase Message_InteractiveResponseMessage::interactiveResponseMessage_case() const {
+  return Message_InteractiveResponseMessage::InteractiveResponseMessageCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_InvoiceMessage
+
+// optional string note = 1;
+inline bool Message_InvoiceMessage::_internal_has_note() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_note() const {
+  return _internal_has_note();
+}
+inline void Message_InvoiceMessage::clear_note() {
+  _impl_.note_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_InvoiceMessage::note() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.note)
+  return _internal_note();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_note(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.note_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.note)
+}
+inline std::string* Message_InvoiceMessage::mutable_note() {
+  std::string* _s = _internal_mutable_note();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.note)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_note() const {
+  return _impl_.note_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_note(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.note_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_note() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.note_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_note() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.note)
+  if (!_internal_has_note()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.note_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.note_.IsDefault()) {
+    _impl_.note_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_note(std::string* note) {
+  if (note != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.note_.SetAllocated(note, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.note_.IsDefault()) {
+    _impl_.note_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.note)
+}
+
+// optional string token = 2;
+inline bool Message_InvoiceMessage::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_token() const {
+  return _internal_has_token();
+}
+inline void Message_InvoiceMessage::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_InvoiceMessage::token() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.token)
+}
+inline std::string* Message_InvoiceMessage::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.token)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_token() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.token)
+}
+
+// optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
+inline bool Message_InvoiceMessage::_internal_has_attachmenttype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmenttype() const {
+  return _internal_has_attachmenttype();
+}
+inline void Message_InvoiceMessage::clear_attachmenttype() {
+  _impl_.attachmenttype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::_internal_attachmenttype() const {
+  return static_cast< ::proto::Message_InvoiceMessage_AttachmentType >(_impl_.attachmenttype_);
+}
+inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::attachmenttype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentType)
+  return _internal_attachmenttype();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) {
+  assert(::proto::Message_InvoiceMessage_AttachmentType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.attachmenttype_ = value;
+}
+inline void Message_InvoiceMessage::set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) {
+  _internal_set_attachmenttype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentType)
+}
+
+// optional string attachmentMimetype = 4;
+inline bool Message_InvoiceMessage::_internal_has_attachmentmimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentmimetype() const {
+  return _internal_has_attachmentmimetype();
+}
+inline void Message_InvoiceMessage::clear_attachmentmimetype() {
+  _impl_.attachmentmimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentmimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMimetype)
+  return _internal_attachmentmimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentmimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.attachmentmimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMimetype)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentmimetype() {
+  std::string* _s = _internal_mutable_attachmentmimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMimetype)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentmimetype() const {
+  return _impl_.attachmentmimetype_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentmimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.attachmentmimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmimetype() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.attachmentmimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentmimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMimetype)
+  if (!_internal_has_attachmentmimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.attachmentmimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentmimetype_.IsDefault()) {
+    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentmimetype(std::string* attachmentmimetype) {
+  if (attachmentmimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.attachmentmimetype_.SetAllocated(attachmentmimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentmimetype_.IsDefault()) {
+    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMimetype)
+}
+
+// optional bytes attachmentMediaKey = 5;
+inline bool Message_InvoiceMessage::_internal_has_attachmentmediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentmediakey() const {
+  return _internal_has_attachmentmediakey();
+}
+inline void Message_InvoiceMessage::clear_attachmentmediakey() {
+  _impl_.attachmentmediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentmediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKey)
+  return _internal_attachmentmediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentmediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.attachmentmediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKey)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentmediakey() {
+  std::string* _s = _internal_mutable_attachmentmediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMediaKey)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentmediakey() const {
+  return _impl_.attachmentmediakey_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentmediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.attachmentmediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmediakey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.attachmentmediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentmediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMediaKey)
+  if (!_internal_has_attachmentmediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.attachmentmediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentmediakey_.IsDefault()) {
+    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentmediakey(std::string* attachmentmediakey) {
+  if (attachmentmediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.attachmentmediakey_.SetAllocated(attachmentmediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentmediakey_.IsDefault()) {
+    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMediaKey)
+}
+
+// optional int64 attachmentMediaKeyTimestamp = 6;
+inline bool Message_InvoiceMessage::_internal_has_attachmentmediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentmediakeytimestamp() const {
+  return _internal_has_attachmentmediakeytimestamp();
+}
+inline void Message_InvoiceMessage::clear_attachmentmediakeytimestamp() {
+  _impl_.attachmentmediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline int64_t Message_InvoiceMessage::_internal_attachmentmediakeytimestamp() const {
+  return _impl_.attachmentmediakeytimestamp_;
+}
+inline int64_t Message_InvoiceMessage::attachmentmediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp)
+  return _internal_attachmentmediakeytimestamp();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentmediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.attachmentmediakeytimestamp_ = value;
+}
+inline void Message_InvoiceMessage::set_attachmentmediakeytimestamp(int64_t value) {
+  _internal_set_attachmentmediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp)
+}
+
+// optional bytes attachmentFileSha256 = 7;
+inline bool Message_InvoiceMessage::_internal_has_attachmentfilesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentfilesha256() const {
+  return _internal_has_attachmentfilesha256();
+}
+inline void Message_InvoiceMessage::clear_attachmentfilesha256() {
+  _impl_.attachmentfilesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentfilesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileSha256)
+  return _internal_attachmentfilesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentfilesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.attachmentfilesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileSha256)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentfilesha256() {
+  std::string* _s = _internal_mutable_attachmentfilesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileSha256)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentfilesha256() const {
+  return _impl_.attachmentfilesha256_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentfilesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.attachmentfilesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfilesha256() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.attachmentfilesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentfilesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileSha256)
+  if (!_internal_has_attachmentfilesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.attachmentfilesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentfilesha256_.IsDefault()) {
+    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentfilesha256(std::string* attachmentfilesha256) {
+  if (attachmentfilesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.attachmentfilesha256_.SetAllocated(attachmentfilesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentfilesha256_.IsDefault()) {
+    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileSha256)
+}
+
+// optional bytes attachmentFileEncSha256 = 8;
+inline bool Message_InvoiceMessage::_internal_has_attachmentfileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentfileencsha256() const {
+  return _internal_has_attachmentfileencsha256();
+}
+inline void Message_InvoiceMessage::clear_attachmentfileencsha256() {
+  _impl_.attachmentfileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentfileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileEncSha256)
+  return _internal_attachmentfileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.attachmentfileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileEncSha256)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentfileencsha256() {
+  std::string* _s = _internal_mutable_attachmentfileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileEncSha256)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentfileencsha256() const {
+  return _impl_.attachmentfileencsha256_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentfileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.attachmentfileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.attachmentfileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentfileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileEncSha256)
+  if (!_internal_has_attachmentfileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.attachmentfileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentfileencsha256_.IsDefault()) {
+    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256) {
+  if (attachmentfileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.attachmentfileencsha256_.SetAllocated(attachmentfileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentfileencsha256_.IsDefault()) {
+    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileEncSha256)
+}
+
+// optional string attachmentDirectPath = 9;
+inline bool Message_InvoiceMessage::_internal_has_attachmentdirectpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentdirectpath() const {
+  return _internal_has_attachmentdirectpath();
+}
+inline void Message_InvoiceMessage::clear_attachmentdirectpath() {
+  _impl_.attachmentdirectpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentdirectpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentDirectPath)
+  return _internal_attachmentdirectpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentdirectpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.attachmentdirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentDirectPath)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentdirectpath() {
+  std::string* _s = _internal_mutable_attachmentdirectpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentDirectPath)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentdirectpath() const {
+  return _impl_.attachmentdirectpath_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentdirectpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.attachmentdirectpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentdirectpath() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.attachmentdirectpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentdirectpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentDirectPath)
+  if (!_internal_has_attachmentdirectpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.attachmentdirectpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentdirectpath_.IsDefault()) {
+    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentdirectpath(std::string* attachmentdirectpath) {
+  if (attachmentdirectpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.attachmentdirectpath_.SetAllocated(attachmentdirectpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentdirectpath_.IsDefault()) {
+    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentDirectPath)
+}
+
+// optional bytes attachmentJpegThumbnail = 10;
+inline bool Message_InvoiceMessage::_internal_has_attachmentjpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_InvoiceMessage::has_attachmentjpegthumbnail() const {
+  return _internal_has_attachmentjpegthumbnail();
+}
+inline void Message_InvoiceMessage::clear_attachmentjpegthumbnail() {
+  _impl_.attachmentjpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_InvoiceMessage::attachmentjpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
+  return _internal_attachmentjpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_InvoiceMessage::set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.attachmentjpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
+}
+inline std::string* Message_InvoiceMessage::mutable_attachmentjpegthumbnail() {
+  std::string* _s = _internal_mutable_attachmentjpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_InvoiceMessage::_internal_attachmentjpegthumbnail() const {
+  return _impl_.attachmentjpegthumbnail_.Get();
+}
+inline void Message_InvoiceMessage::_internal_set_attachmentjpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.attachmentjpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentjpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.attachmentjpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_InvoiceMessage::release_attachmentjpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
+  if (!_internal_has_attachmentjpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.attachmentjpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentjpegthumbnail_.IsDefault()) {
+    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_InvoiceMessage::set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail) {
+  if (attachmentjpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.attachmentjpegthumbnail_.SetAllocated(attachmentjpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.attachmentjpegthumbnail_.IsDefault()) {
+    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
+}
+
+// -------------------------------------------------------------------
+
+// Message_KeepInChatMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool Message_KeepInChatMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Message_KeepInChatMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void Message_KeepInChatMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& Message_KeepInChatMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_KeepInChatMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.key)
+  return _internal_key();
+}
+inline void Message_KeepInChatMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.KeepInChatMessage.key)
+}
+inline ::proto::MessageKey* Message_KeepInChatMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_KeepInChatMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Message.KeepInChatMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_KeepInChatMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Message_KeepInChatMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Message.KeepInChatMessage.key)
+  return _msg;
+}
+inline void Message_KeepInChatMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.KeepInChatMessage.key)
+}
+
+// optional .proto.KeepType keepType = 2;
+inline bool Message_KeepInChatMessage::_internal_has_keeptype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_KeepInChatMessage::has_keeptype() const {
+  return _internal_has_keeptype();
+}
+inline void Message_KeepInChatMessage::clear_keeptype() {
+  _impl_.keeptype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::KeepType Message_KeepInChatMessage::_internal_keeptype() const {
+  return static_cast< ::proto::KeepType >(_impl_.keeptype_);
+}
+inline ::proto::KeepType Message_KeepInChatMessage::keeptype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.keepType)
+  return _internal_keeptype();
+}
+inline void Message_KeepInChatMessage::_internal_set_keeptype(::proto::KeepType value) {
+  assert(::proto::KeepType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.keeptype_ = value;
+}
+inline void Message_KeepInChatMessage::set_keeptype(::proto::KeepType value) {
+  _internal_set_keeptype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.keepType)
+}
+
+// optional int64 timestampMs = 3;
+inline bool Message_KeepInChatMessage::_internal_has_timestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_KeepInChatMessage::has_timestampms() const {
+  return _internal_has_timestampms();
+}
+inline void Message_KeepInChatMessage::clear_timestampms() {
+  _impl_.timestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t Message_KeepInChatMessage::_internal_timestampms() const {
+  return _impl_.timestampms_;
+}
+inline int64_t Message_KeepInChatMessage::timestampms() const {
+  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.timestampMs)
+  return _internal_timestampms();
+}
+inline void Message_KeepInChatMessage::_internal_set_timestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.timestampms_ = value;
+}
+inline void Message_KeepInChatMessage::set_timestampms(int64_t value) {
+  _internal_set_timestampms(value);
+  // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.timestampMs)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_ProductListHeaderImage
+
+// optional string productId = 1;
+inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_productid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_ProductListHeaderImage::has_productid() const {
+  return _internal_has_productid();
+}
+inline void Message_ListMessage_ProductListHeaderImage::clear_productid() {
+  _impl_.productid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_ProductListHeaderImage::productid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.productId)
+  return _internal_productid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_ProductListHeaderImage::set_productid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.productId)
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_productid() {
+  std::string* _s = _internal_mutable_productid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.productId)
+  return _s;
+}
+inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_productid() const {
+  return _impl_.productid_.Get();
+}
+inline void Message_ListMessage_ProductListHeaderImage::_internal_set_productid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.productid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_productid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.productid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::release_productid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.productId)
+  if (!_internal_has_productid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.productid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_ProductListHeaderImage::set_allocated_productid(std::string* productid) {
+  if (productid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.productId)
+}
+
+// optional bytes jpegThumbnail = 2;
+inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_ProductListHeaderImage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_ListMessage_ProductListHeaderImage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ListMessage_ProductListHeaderImage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_ProductListHeaderImage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_ListMessage_ProductListHeaderImage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListHeaderImage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_ProductListHeaderImage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_ProductListInfo
+
+// repeated .proto.Message.ListMessage.ProductSection productSections = 1;
+inline int Message_ListMessage_ProductListInfo::_internal_productsections_size() const {
+  return _impl_.productsections_.size();
+}
+inline int Message_ListMessage_ProductListInfo::productsections_size() const {
+  return _internal_productsections_size();
+}
+inline void Message_ListMessage_ProductListInfo::clear_productsections() {
+  _impl_.productsections_.Clear();
+}
+inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::mutable_productsections(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.productSections)
+  return _impl_.productsections_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >*
+Message_ListMessage_ProductListInfo::mutable_productsections() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductListInfo.productSections)
+  return &_impl_.productsections_;
+}
+inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::_internal_productsections(int index) const {
+  return _impl_.productsections_.Get(index);
+}
+inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::productsections(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.productSections)
+  return _internal_productsections(index);
+}
+inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::_internal_add_productsections() {
+  return _impl_.productsections_.Add();
+}
+inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::add_productsections() {
+  ::proto::Message_ListMessage_ProductSection* _add = _internal_add_productsections();
+  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductListInfo.productSections)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >&
+Message_ListMessage_ProductListInfo::productsections() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductListInfo.productSections)
+  return _impl_.productsections_;
+}
+
+// optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
+inline bool Message_ListMessage_ProductListInfo::_internal_has_headerimage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.headerimage_ != nullptr);
+  return value;
+}
+inline bool Message_ListMessage_ProductListInfo::has_headerimage() const {
+  return _internal_has_headerimage();
+}
+inline void Message_ListMessage_ProductListInfo::clear_headerimage() {
+  if (_impl_.headerimage_ != nullptr) _impl_.headerimage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::_internal_headerimage() const {
+  const ::proto::Message_ListMessage_ProductListHeaderImage* p = _impl_.headerimage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage_ProductListHeaderImage&>(
+      ::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_);
+}
+inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::headerimage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.headerImage)
+  return _internal_headerimage();
+}
+inline void Message_ListMessage_ProductListInfo::unsafe_arena_set_allocated_headerimage(
+    ::proto::Message_ListMessage_ProductListHeaderImage* headerimage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.headerimage_);
+  }
+  _impl_.headerimage_ = headerimage;
+  if (headerimage) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage)
+}
+inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::release_headerimage() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_;
+  _impl_.headerimage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::unsafe_arena_release_headerimage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.headerImage)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_;
+  _impl_.headerimage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::_internal_mutable_headerimage() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.headerimage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(GetArenaForAllocation());
+    _impl_.headerimage_ = p;
+  }
+  return _impl_.headerimage_;
+}
+inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::mutable_headerimage() {
+  ::proto::Message_ListMessage_ProductListHeaderImage* _msg = _internal_mutable_headerimage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.headerImage)
+  return _msg;
+}
+inline void Message_ListMessage_ProductListInfo::set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.headerimage_;
+  }
+  if (headerimage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(headerimage);
+    if (message_arena != submessage_arena) {
+      headerimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, headerimage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.headerimage_ = headerimage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage)
+}
+
+// optional string businessOwnerJid = 3;
+inline bool Message_ListMessage_ProductListInfo::_internal_has_businessownerjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_ProductListInfo::has_businessownerjid() const {
+  return _internal_has_businessownerjid();
+}
+inline void Message_ListMessage_ProductListInfo::clear_businessownerjid() {
+  _impl_.businessownerjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_ProductListInfo::businessownerjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
+  return _internal_businessownerjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_ProductListInfo::set_businessownerjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.businessownerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
+}
+inline std::string* Message_ListMessage_ProductListInfo::mutable_businessownerjid() {
+  std::string* _s = _internal_mutable_businessownerjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
+  return _s;
+}
+inline const std::string& Message_ListMessage_ProductListInfo::_internal_businessownerjid() const {
+  return _impl_.businessownerjid_.Get();
+}
+inline void Message_ListMessage_ProductListInfo::_internal_set_businessownerjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.businessownerjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListInfo::_internal_mutable_businessownerjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.businessownerjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductListInfo::release_businessownerjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
+  if (!_internal_has_businessownerjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.businessownerjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.businessownerjid_.IsDefault()) {
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_ProductListInfo::set_allocated_businessownerjid(std::string* businessownerjid) {
+  if (businessownerjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.businessownerjid_.IsDefault()) {
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_ProductSection
+
+// optional string title = 1;
+inline bool Message_ListMessage_ProductSection::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_ProductSection::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ListMessage_ProductSection::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_ProductSection::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_ProductSection::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductSection.title)
+}
+inline std::string* Message_ListMessage_ProductSection::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.title)
+  return _s;
+}
+inline const std::string& Message_ListMessage_ProductSection::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ListMessage_ProductSection::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductSection::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_ProductSection::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductSection.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_ProductSection::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductSection.title)
+}
+
+// repeated .proto.Message.ListMessage.Product products = 2;
+inline int Message_ListMessage_ProductSection::_internal_products_size() const {
+  return _impl_.products_.size();
+}
+inline int Message_ListMessage_ProductSection::products_size() const {
+  return _internal_products_size();
+}
+inline void Message_ListMessage_ProductSection::clear_products() {
+  _impl_.products_.Clear();
+}
+inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::mutable_products(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.products)
+  return _impl_.products_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >*
+Message_ListMessage_ProductSection::mutable_products() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductSection.products)
+  return &_impl_.products_;
+}
+inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::_internal_products(int index) const {
+  return _impl_.products_.Get(index);
+}
+inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::products(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.products)
+  return _internal_products(index);
+}
+inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::_internal_add_products() {
+  return _impl_.products_.Add();
+}
+inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::add_products() {
+  ::proto::Message_ListMessage_Product* _add = _internal_add_products();
+  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductSection.products)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >&
+Message_ListMessage_ProductSection::products() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductSection.products)
+  return _impl_.products_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_Product
+
+// optional string productId = 1;
+inline bool Message_ListMessage_Product::_internal_has_productid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_Product::has_productid() const {
+  return _internal_has_productid();
+}
+inline void Message_ListMessage_Product::clear_productid() {
+  _impl_.productid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_Product::productid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Product.productId)
+  return _internal_productid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_Product::set_productid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Product.productId)
+}
+inline std::string* Message_ListMessage_Product::mutable_productid() {
+  std::string* _s = _internal_mutable_productid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Product.productId)
+  return _s;
+}
+inline const std::string& Message_ListMessage_Product::_internal_productid() const {
+  return _impl_.productid_.Get();
+}
+inline void Message_ListMessage_Product::_internal_set_productid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.productid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Product::_internal_mutable_productid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.productid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Product::release_productid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Product.productId)
+  if (!_internal_has_productid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.productid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_Product::set_allocated_productid(std::string* productid) {
+  if (productid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Product.productId)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_Row
+
+// optional string title = 1;
+inline bool Message_ListMessage_Row::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_Row::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ListMessage_Row::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_Row::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_Row::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.title)
+}
+inline std::string* Message_ListMessage_Row::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.title)
+  return _s;
+}
+inline const std::string& Message_ListMessage_Row::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ListMessage_Row::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_Row::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.title)
+}
+
+// optional string description = 2;
+inline bool Message_ListMessage_Row::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_Row::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ListMessage_Row::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ListMessage_Row::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_Row::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.description)
+}
+inline std::string* Message_ListMessage_Row::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.description)
+  return _s;
+}
+inline const std::string& Message_ListMessage_Row::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ListMessage_Row::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_Row::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.description)
+}
+
+// optional string rowId = 3;
+inline bool Message_ListMessage_Row::_internal_has_rowid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_Row::has_rowid() const {
+  return _internal_has_rowid();
+}
+inline void Message_ListMessage_Row::clear_rowid() {
+  _impl_.rowid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ListMessage_Row::rowid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.rowId)
+  return _internal_rowid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_Row::set_rowid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.rowid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.rowId)
+}
+inline std::string* Message_ListMessage_Row::mutable_rowid() {
+  std::string* _s = _internal_mutable_rowid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.rowId)
+  return _s;
+}
+inline const std::string& Message_ListMessage_Row::_internal_rowid() const {
+  return _impl_.rowid_.Get();
+}
+inline void Message_ListMessage_Row::_internal_set_rowid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.rowid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::_internal_mutable_rowid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.rowid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Row::release_rowid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.rowId)
+  if (!_internal_has_rowid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.rowid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rowid_.IsDefault()) {
+    _impl_.rowid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_Row::set_allocated_rowid(std::string* rowid) {
+  if (rowid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.rowid_.SetAllocated(rowid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rowid_.IsDefault()) {
+    _impl_.rowid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.rowId)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage_Section
+
+// optional string title = 1;
+inline bool Message_ListMessage_Section::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage_Section::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ListMessage_Section::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage_Section::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage_Section::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Section.title)
+}
+inline std::string* Message_ListMessage_Section::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.title)
+  return _s;
+}
+inline const std::string& Message_ListMessage_Section::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ListMessage_Section::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Section::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage_Section::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Section.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage_Section::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Section.title)
+}
+
+// repeated .proto.Message.ListMessage.Row rows = 2;
+inline int Message_ListMessage_Section::_internal_rows_size() const {
+  return _impl_.rows_.size();
+}
+inline int Message_ListMessage_Section::rows_size() const {
+  return _internal_rows_size();
+}
+inline void Message_ListMessage_Section::clear_rows() {
+  _impl_.rows_.Clear();
+}
+inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::mutable_rows(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.rows)
+  return _impl_.rows_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >*
+Message_ListMessage_Section::mutable_rows() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.Section.rows)
+  return &_impl_.rows_;
+}
+inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::_internal_rows(int index) const {
+  return _impl_.rows_.Get(index);
+}
+inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::rows(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.rows)
+  return _internal_rows(index);
+}
+inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::_internal_add_rows() {
+  return _impl_.rows_.Add();
+}
+inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::add_rows() {
+  ::proto::Message_ListMessage_Row* _add = _internal_add_rows();
+  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.Section.rows)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >&
+Message_ListMessage_Section::rows() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.Section.rows)
+  return _impl_.rows_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListMessage
+
+// optional string title = 1;
+inline bool Message_ListMessage::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListMessage::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ListMessage::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListMessage::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.title)
+}
+inline std::string* Message_ListMessage::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.title)
+  return _s;
+}
+inline const std::string& Message_ListMessage::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ListMessage::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.title)
+}
+
+// optional string description = 2;
+inline bool Message_ListMessage::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ListMessage::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ListMessage::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ListMessage::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.description)
+}
+inline std::string* Message_ListMessage::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.description)
+  return _s;
+}
+inline const std::string& Message_ListMessage::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ListMessage::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.description)
+}
+
+// optional string buttonText = 3;
+inline bool Message_ListMessage::_internal_has_buttontext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ListMessage::has_buttontext() const {
+  return _internal_has_buttontext();
+}
+inline void Message_ListMessage::clear_buttontext() {
+  _impl_.buttontext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ListMessage::buttontext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.buttonText)
+  return _internal_buttontext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage::set_buttontext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.buttontext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.buttonText)
+}
+inline std::string* Message_ListMessage::mutable_buttontext() {
+  std::string* _s = _internal_mutable_buttontext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.buttonText)
+  return _s;
+}
+inline const std::string& Message_ListMessage::_internal_buttontext() const {
+  return _impl_.buttontext_.Get();
+}
+inline void Message_ListMessage::_internal_set_buttontext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.buttontext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::_internal_mutable_buttontext() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.buttontext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::release_buttontext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.buttonText)
+  if (!_internal_has_buttontext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.buttontext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttontext_.IsDefault()) {
+    _impl_.buttontext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage::set_allocated_buttontext(std::string* buttontext) {
+  if (buttontext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.buttontext_.SetAllocated(buttontext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.buttontext_.IsDefault()) {
+    _impl_.buttontext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.buttonText)
+}
+
+// optional .proto.Message.ListMessage.ListType listType = 4;
+inline bool Message_ListMessage::_internal_has_listtype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_ListMessage::has_listtype() const {
+  return _internal_has_listtype();
+}
+inline void Message_ListMessage::clear_listtype() {
+  _impl_.listtype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::proto::Message_ListMessage_ListType Message_ListMessage::_internal_listtype() const {
+  return static_cast< ::proto::Message_ListMessage_ListType >(_impl_.listtype_);
+}
+inline ::proto::Message_ListMessage_ListType Message_ListMessage::listtype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.listType)
+  return _internal_listtype();
+}
+inline void Message_ListMessage::_internal_set_listtype(::proto::Message_ListMessage_ListType value) {
+  assert(::proto::Message_ListMessage_ListType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.listtype_ = value;
+}
+inline void Message_ListMessage::set_listtype(::proto::Message_ListMessage_ListType value) {
+  _internal_set_listtype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.listType)
+}
+
+// repeated .proto.Message.ListMessage.Section sections = 5;
+inline int Message_ListMessage::_internal_sections_size() const {
+  return _impl_.sections_.size();
+}
+inline int Message_ListMessage::sections_size() const {
+  return _internal_sections_size();
+}
+inline void Message_ListMessage::clear_sections() {
+  _impl_.sections_.Clear();
+}
+inline ::proto::Message_ListMessage_Section* Message_ListMessage::mutable_sections(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.sections)
+  return _impl_.sections_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >*
+Message_ListMessage::mutable_sections() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.sections)
+  return &_impl_.sections_;
+}
+inline const ::proto::Message_ListMessage_Section& Message_ListMessage::_internal_sections(int index) const {
+  return _impl_.sections_.Get(index);
+}
+inline const ::proto::Message_ListMessage_Section& Message_ListMessage::sections(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.sections)
+  return _internal_sections(index);
+}
+inline ::proto::Message_ListMessage_Section* Message_ListMessage::_internal_add_sections() {
+  return _impl_.sections_.Add();
+}
+inline ::proto::Message_ListMessage_Section* Message_ListMessage::add_sections() {
+  ::proto::Message_ListMessage_Section* _add = _internal_add_sections();
+  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.sections)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >&
+Message_ListMessage::sections() const {
+  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.sections)
+  return _impl_.sections_;
+}
+
+// optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
+inline bool Message_ListMessage::_internal_has_productlistinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.productlistinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ListMessage::has_productlistinfo() const {
+  return _internal_has_productlistinfo();
+}
+inline void Message_ListMessage::clear_productlistinfo() {
+  if (_impl_.productlistinfo_ != nullptr) _impl_.productlistinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::_internal_productlistinfo() const {
+  const ::proto::Message_ListMessage_ProductListInfo* p = _impl_.productlistinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage_ProductListInfo&>(
+      ::proto::_Message_ListMessage_ProductListInfo_default_instance_);
+}
+inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::productlistinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.productListInfo)
+  return _internal_productlistinfo();
+}
+inline void Message_ListMessage::unsafe_arena_set_allocated_productlistinfo(
+    ::proto::Message_ListMessage_ProductListInfo* productlistinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productlistinfo_);
+  }
+  _impl_.productlistinfo_ = productlistinfo;
+  if (productlistinfo) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.productListInfo)
+}
+inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::release_productlistinfo() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_;
+  _impl_.productlistinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::unsafe_arena_release_productlistinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.productListInfo)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_;
+  _impl_.productlistinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::_internal_mutable_productlistinfo() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.productlistinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(GetArenaForAllocation());
+    _impl_.productlistinfo_ = p;
+  }
+  return _impl_.productlistinfo_;
+}
+inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::mutable_productlistinfo() {
+  ::proto::Message_ListMessage_ProductListInfo* _msg = _internal_mutable_productlistinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.productListInfo)
+  return _msg;
+}
+inline void Message_ListMessage::set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.productlistinfo_;
+  }
+  if (productlistinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productlistinfo);
+    if (message_arena != submessage_arena) {
+      productlistinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, productlistinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.productlistinfo_ = productlistinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.productListInfo)
+}
+
+// optional string footerText = 7;
+inline bool Message_ListMessage::_internal_has_footertext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ListMessage::has_footertext() const {
+  return _internal_has_footertext();
+}
+inline void Message_ListMessage::clear_footertext() {
+  _impl_.footertext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_ListMessage::footertext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.footerText)
+  return _internal_footertext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListMessage::set_footertext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.footertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.footerText)
+}
+inline std::string* Message_ListMessage::mutable_footertext() {
+  std::string* _s = _internal_mutable_footertext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.footerText)
+  return _s;
+}
+inline const std::string& Message_ListMessage::_internal_footertext() const {
+  return _impl_.footertext_.Get();
+}
+inline void Message_ListMessage::_internal_set_footertext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.footertext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::_internal_mutable_footertext() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.footertext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListMessage::release_footertext() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.footerText)
+  if (!_internal_has_footertext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.footertext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footertext_.IsDefault()) {
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListMessage::set_allocated_footertext(std::string* footertext) {
+  if (footertext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footertext_.IsDefault()) {
+    _impl_.footertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.footerText)
+}
+
+// optional .proto.ContextInfo contextInfo = 8;
+inline bool Message_ListMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ListMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ListMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ContextInfo& Message_ListMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ListMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ListMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ListMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ListMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ListMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ListMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ListMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListResponseMessage_SingleSelectReply
+
+// optional string selectedRowId = 1;
+inline bool Message_ListResponseMessage_SingleSelectReply::_internal_has_selectedrowid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListResponseMessage_SingleSelectReply::has_selectedrowid() const {
+  return _internal_has_selectedrowid();
+}
+inline void Message_ListResponseMessage_SingleSelectReply::clear_selectedrowid() {
+  _impl_.selectedrowid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListResponseMessage_SingleSelectReply::selectedrowid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
+  return _internal_selectedrowid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListResponseMessage_SingleSelectReply::set_selectedrowid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.selectedrowid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
+}
+inline std::string* Message_ListResponseMessage_SingleSelectReply::mutable_selectedrowid() {
+  std::string* _s = _internal_mutable_selectedrowid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
+  return _s;
+}
+inline const std::string& Message_ListResponseMessage_SingleSelectReply::_internal_selectedrowid() const {
+  return _impl_.selectedrowid_.Get();
+}
+inline void Message_ListResponseMessage_SingleSelectReply::_internal_set_selectedrowid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.selectedrowid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage_SingleSelectReply::_internal_mutable_selectedrowid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.selectedrowid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage_SingleSelectReply::release_selectedrowid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
+  if (!_internal_has_selectedrowid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.selectedrowid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedrowid_.IsDefault()) {
+    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListResponseMessage_SingleSelectReply::set_allocated_selectedrowid(std::string* selectedrowid) {
+  if (selectedrowid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.selectedrowid_.SetAllocated(selectedrowid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedrowid_.IsDefault()) {
+    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ListResponseMessage
+
+// optional string title = 1;
+inline bool Message_ListResponseMessage::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ListResponseMessage::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ListResponseMessage::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ListResponseMessage::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListResponseMessage::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.title)
+}
+inline std::string* Message_ListResponseMessage::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.title)
+  return _s;
+}
+inline const std::string& Message_ListResponseMessage::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ListResponseMessage::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListResponseMessage::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.title)
+}
+
+// optional .proto.Message.ListResponseMessage.ListType listType = 2;
+inline bool Message_ListResponseMessage::_internal_has_listtype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_ListResponseMessage::has_listtype() const {
+  return _internal_has_listtype();
+}
+inline void Message_ListResponseMessage::clear_listtype() {
+  _impl_.listtype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::_internal_listtype() const {
+  return static_cast< ::proto::Message_ListResponseMessage_ListType >(_impl_.listtype_);
+}
+inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::listtype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.listType)
+  return _internal_listtype();
+}
+inline void Message_ListResponseMessage::_internal_set_listtype(::proto::Message_ListResponseMessage_ListType value) {
+  assert(::proto::Message_ListResponseMessage_ListType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.listtype_ = value;
+}
+inline void Message_ListResponseMessage::set_listtype(::proto::Message_ListResponseMessage_ListType value) {
+  _internal_set_listtype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.listType)
+}
+
+// optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
+inline bool Message_ListResponseMessage::_internal_has_singleselectreply() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.singleselectreply_ != nullptr);
+  return value;
+}
+inline bool Message_ListResponseMessage::has_singleselectreply() const {
+  return _internal_has_singleselectreply();
+}
+inline void Message_ListResponseMessage::clear_singleselectreply() {
+  if (_impl_.singleselectreply_ != nullptr) _impl_.singleselectreply_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::_internal_singleselectreply() const {
+  const ::proto::Message_ListResponseMessage_SingleSelectReply* p = _impl_.singleselectreply_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListResponseMessage_SingleSelectReply&>(
+      ::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_);
+}
+inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::singleselectreply() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.singleSelectReply)
+  return _internal_singleselectreply();
+}
+inline void Message_ListResponseMessage::unsafe_arena_set_allocated_singleselectreply(
+    ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.singleselectreply_);
+  }
+  _impl_.singleselectreply_ = singleselectreply;
+  if (singleselectreply) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.singleSelectReply)
+}
+inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::release_singleselectreply() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_;
+  _impl_.singleselectreply_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::unsafe_arena_release_singleselectreply() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.singleSelectReply)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_;
+  _impl_.singleselectreply_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::_internal_mutable_singleselectreply() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.singleselectreply_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(GetArenaForAllocation());
+    _impl_.singleselectreply_ = p;
+  }
+  return _impl_.singleselectreply_;
+}
+inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::mutable_singleselectreply() {
+  ::proto::Message_ListResponseMessage_SingleSelectReply* _msg = _internal_mutable_singleselectreply();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.singleSelectReply)
+  return _msg;
+}
+inline void Message_ListResponseMessage::set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.singleselectreply_;
+  }
+  if (singleselectreply) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(singleselectreply);
+    if (message_arena != submessage_arena) {
+      singleselectreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, singleselectreply, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.singleselectreply_ = singleselectreply;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.singleSelectReply)
+}
+
+// optional .proto.ContextInfo contextInfo = 4;
+inline bool Message_ListResponseMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ListResponseMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ListResponseMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::ContextInfo& Message_ListResponseMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ListResponseMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ListResponseMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ListResponseMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ListResponseMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ListResponseMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ListResponseMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ListResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.contextInfo)
+}
+
+// optional string description = 5;
+inline bool Message_ListResponseMessage::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ListResponseMessage::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ListResponseMessage::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ListResponseMessage::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ListResponseMessage::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.description)
+}
+inline std::string* Message_ListResponseMessage::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.description)
+  return _s;
+}
+inline const std::string& Message_ListResponseMessage::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ListResponseMessage::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ListResponseMessage::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ListResponseMessage::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.description)
+}
+
+// -------------------------------------------------------------------
+
+// Message_LiveLocationMessage
+
+// optional double degreesLatitude = 1;
+inline bool Message_LiveLocationMessage::_internal_has_degreeslatitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_degreeslatitude() const {
+  return _internal_has_degreeslatitude();
+}
+inline void Message_LiveLocationMessage::clear_degreeslatitude() {
+  _impl_.degreeslatitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline double Message_LiveLocationMessage::_internal_degreeslatitude() const {
+  return _impl_.degreeslatitude_;
+}
+inline double Message_LiveLocationMessage::degreeslatitude() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLatitude)
+  return _internal_degreeslatitude();
+}
+inline void Message_LiveLocationMessage::_internal_set_degreeslatitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.degreeslatitude_ = value;
+}
+inline void Message_LiveLocationMessage::set_degreeslatitude(double value) {
+  _internal_set_degreeslatitude(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLatitude)
+}
+
+// optional double degreesLongitude = 2;
+inline bool Message_LiveLocationMessage::_internal_has_degreeslongitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_degreeslongitude() const {
+  return _internal_has_degreeslongitude();
+}
+inline void Message_LiveLocationMessage::clear_degreeslongitude() {
+  _impl_.degreeslongitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline double Message_LiveLocationMessage::_internal_degreeslongitude() const {
+  return _impl_.degreeslongitude_;
+}
+inline double Message_LiveLocationMessage::degreeslongitude() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLongitude)
+  return _internal_degreeslongitude();
+}
+inline void Message_LiveLocationMessage::_internal_set_degreeslongitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.degreeslongitude_ = value;
+}
+inline void Message_LiveLocationMessage::set_degreeslongitude(double value) {
+  _internal_set_degreeslongitude(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLongitude)
+}
+
+// optional uint32 accuracyInMeters = 3;
+inline bool Message_LiveLocationMessage::_internal_has_accuracyinmeters() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_accuracyinmeters() const {
+  return _internal_has_accuracyinmeters();
+}
+inline void Message_LiveLocationMessage::clear_accuracyinmeters() {
+  _impl_.accuracyinmeters_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint32_t Message_LiveLocationMessage::_internal_accuracyinmeters() const {
+  return _impl_.accuracyinmeters_;
+}
+inline uint32_t Message_LiveLocationMessage::accuracyinmeters() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.accuracyInMeters)
+  return _internal_accuracyinmeters();
+}
+inline void Message_LiveLocationMessage::_internal_set_accuracyinmeters(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.accuracyinmeters_ = value;
+}
+inline void Message_LiveLocationMessage::set_accuracyinmeters(uint32_t value) {
+  _internal_set_accuracyinmeters(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.accuracyInMeters)
+}
+
+// optional float speedInMps = 4;
+inline bool Message_LiveLocationMessage::_internal_has_speedinmps() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_speedinmps() const {
+  return _internal_has_speedinmps();
+}
+inline void Message_LiveLocationMessage::clear_speedinmps() {
+  _impl_.speedinmps_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline float Message_LiveLocationMessage::_internal_speedinmps() const {
+  return _impl_.speedinmps_;
+}
+inline float Message_LiveLocationMessage::speedinmps() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.speedInMps)
+  return _internal_speedinmps();
+}
+inline void Message_LiveLocationMessage::_internal_set_speedinmps(float value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.speedinmps_ = value;
+}
+inline void Message_LiveLocationMessage::set_speedinmps(float value) {
+  _internal_set_speedinmps(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.speedInMps)
+}
+
+// optional uint32 degreesClockwiseFromMagneticNorth = 5;
+inline bool Message_LiveLocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_degreesclockwisefrommagneticnorth() const {
+  return _internal_has_degreesclockwisefrommagneticnorth();
+}
+inline void Message_LiveLocationMessage::clear_degreesclockwisefrommagneticnorth() {
+  _impl_.degreesclockwisefrommagneticnorth_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint32_t Message_LiveLocationMessage::_internal_degreesclockwisefrommagneticnorth() const {
+  return _impl_.degreesclockwisefrommagneticnorth_;
+}
+inline uint32_t Message_LiveLocationMessage::degreesclockwisefrommagneticnorth() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth)
+  return _internal_degreesclockwisefrommagneticnorth();
+}
+inline void Message_LiveLocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.degreesclockwisefrommagneticnorth_ = value;
+}
+inline void Message_LiveLocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) {
+  _internal_set_degreesclockwisefrommagneticnorth(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth)
+}
+
+// optional string caption = 6;
+inline bool Message_LiveLocationMessage::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_caption() const {
+  return _internal_has_caption();
+}
+inline void Message_LiveLocationMessage::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_LiveLocationMessage::caption() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LiveLocationMessage::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.caption)
+}
+inline std::string* Message_LiveLocationMessage::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.caption)
+  return _s;
+}
+inline const std::string& Message_LiveLocationMessage::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void Message_LiveLocationMessage::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LiveLocationMessage::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LiveLocationMessage::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LiveLocationMessage::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.caption)
+}
+
+// optional int64 sequenceNumber = 7;
+inline bool Message_LiveLocationMessage::_internal_has_sequencenumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_sequencenumber() const {
+  return _internal_has_sequencenumber();
+}
+inline void Message_LiveLocationMessage::clear_sequencenumber() {
+  _impl_.sequencenumber_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline int64_t Message_LiveLocationMessage::_internal_sequencenumber() const {
+  return _impl_.sequencenumber_;
+}
+inline int64_t Message_LiveLocationMessage::sequencenumber() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.sequenceNumber)
+  return _internal_sequencenumber();
+}
+inline void Message_LiveLocationMessage::_internal_set_sequencenumber(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.sequencenumber_ = value;
+}
+inline void Message_LiveLocationMessage::set_sequencenumber(int64_t value) {
+  _internal_set_sequencenumber(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.sequenceNumber)
+}
+
+// optional uint32 timeOffset = 8;
+inline bool Message_LiveLocationMessage::_internal_has_timeoffset() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_timeoffset() const {
+  return _internal_has_timeoffset();
+}
+inline void Message_LiveLocationMessage::clear_timeoffset() {
+  _impl_.timeoffset_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint32_t Message_LiveLocationMessage::_internal_timeoffset() const {
+  return _impl_.timeoffset_;
+}
+inline uint32_t Message_LiveLocationMessage::timeoffset() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.timeOffset)
+  return _internal_timeoffset();
+}
+inline void Message_LiveLocationMessage::_internal_set_timeoffset(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.timeoffset_ = value;
+}
+inline void Message_LiveLocationMessage::set_timeoffset(uint32_t value) {
+  _internal_set_timeoffset(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.timeOffset)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_LiveLocationMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_LiveLocationMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_LiveLocationMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LiveLocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.jpegThumbnail)
+}
+inline std::string* Message_LiveLocationMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_LiveLocationMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_LiveLocationMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LiveLocationMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LiveLocationMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LiveLocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_LiveLocationMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_LiveLocationMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_LiveLocationMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ContextInfo& Message_LiveLocationMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_LiveLocationMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_LiveLocationMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LiveLocationMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_LiveLocationMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_LiveLocationMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_LiveLocationMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_LiveLocationMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.contextInfo)
+  return _msg;
+}
+inline void Message_LiveLocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_LocationMessage
+
+// optional double degreesLatitude = 1;
+inline bool Message_LocationMessage::_internal_has_degreeslatitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_degreeslatitude() const {
+  return _internal_has_degreeslatitude();
+}
+inline void Message_LocationMessage::clear_degreeslatitude() {
+  _impl_.degreeslatitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline double Message_LocationMessage::_internal_degreeslatitude() const {
+  return _impl_.degreeslatitude_;
+}
+inline double Message_LocationMessage::degreeslatitude() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLatitude)
+  return _internal_degreeslatitude();
+}
+inline void Message_LocationMessage::_internal_set_degreeslatitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.degreeslatitude_ = value;
+}
+inline void Message_LocationMessage::set_degreeslatitude(double value) {
+  _internal_set_degreeslatitude(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLatitude)
+}
+
+// optional double degreesLongitude = 2;
+inline bool Message_LocationMessage::_internal_has_degreeslongitude() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_degreeslongitude() const {
+  return _internal_has_degreeslongitude();
+}
+inline void Message_LocationMessage::clear_degreeslongitude() {
+  _impl_.degreeslongitude_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline double Message_LocationMessage::_internal_degreeslongitude() const {
+  return _impl_.degreeslongitude_;
+}
+inline double Message_LocationMessage::degreeslongitude() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLongitude)
+  return _internal_degreeslongitude();
+}
+inline void Message_LocationMessage::_internal_set_degreeslongitude(double value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.degreeslongitude_ = value;
+}
+inline void Message_LocationMessage::set_degreeslongitude(double value) {
+  _internal_set_degreeslongitude(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLongitude)
+}
+
+// optional string name = 3;
+inline bool Message_LocationMessage::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_name() const {
+  return _internal_has_name();
+}
+inline void Message_LocationMessage::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_LocationMessage::name() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LocationMessage::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.name)
+}
+inline std::string* Message_LocationMessage::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.name)
+  return _s;
+}
+inline const std::string& Message_LocationMessage::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Message_LocationMessage::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LocationMessage::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.name)
+}
+
+// optional string address = 4;
+inline bool Message_LocationMessage::_internal_has_address() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_address() const {
+  return _internal_has_address();
+}
+inline void Message_LocationMessage::clear_address() {
+  _impl_.address_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_LocationMessage::address() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.address)
+  return _internal_address();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LocationMessage::set_address(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.address)
+}
+inline std::string* Message_LocationMessage::mutable_address() {
+  std::string* _s = _internal_mutable_address();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.address)
+  return _s;
+}
+inline const std::string& Message_LocationMessage::_internal_address() const {
+  return _impl_.address_.Get();
+}
+inline void Message_LocationMessage::_internal_set_address(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.address_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::_internal_mutable_address() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.address_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::release_address() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.address)
+  if (!_internal_has_address()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.address_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.address_.IsDefault()) {
+    _impl_.address_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LocationMessage::set_allocated_address(std::string* address) {
+  if (address != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.address_.SetAllocated(address, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.address_.IsDefault()) {
+    _impl_.address_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.address)
+}
+
+// optional string url = 5;
+inline bool Message_LocationMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_LocationMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_LocationMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LocationMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.url)
+}
+inline std::string* Message_LocationMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.url)
+  return _s;
+}
+inline const std::string& Message_LocationMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_LocationMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LocationMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.url)
+}
+
+// optional bool isLive = 6;
+inline bool Message_LocationMessage::_internal_has_islive() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_islive() const {
+  return _internal_has_islive();
+}
+inline void Message_LocationMessage::clear_islive() {
+  _impl_.islive_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool Message_LocationMessage::_internal_islive() const {
+  return _impl_.islive_;
+}
+inline bool Message_LocationMessage::islive() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.isLive)
+  return _internal_islive();
+}
+inline void Message_LocationMessage::_internal_set_islive(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.islive_ = value;
+}
+inline void Message_LocationMessage::set_islive(bool value) {
+  _internal_set_islive(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.isLive)
+}
+
+// optional uint32 accuracyInMeters = 7;
+inline bool Message_LocationMessage::_internal_has_accuracyinmeters() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_accuracyinmeters() const {
+  return _internal_has_accuracyinmeters();
+}
+inline void Message_LocationMessage::clear_accuracyinmeters() {
+  _impl_.accuracyinmeters_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint32_t Message_LocationMessage::_internal_accuracyinmeters() const {
+  return _impl_.accuracyinmeters_;
+}
+inline uint32_t Message_LocationMessage::accuracyinmeters() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.accuracyInMeters)
+  return _internal_accuracyinmeters();
+}
+inline void Message_LocationMessage::_internal_set_accuracyinmeters(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.accuracyinmeters_ = value;
+}
+inline void Message_LocationMessage::set_accuracyinmeters(uint32_t value) {
+  _internal_set_accuracyinmeters(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.accuracyInMeters)
+}
+
+// optional float speedInMps = 8;
+inline bool Message_LocationMessage::_internal_has_speedinmps() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_speedinmps() const {
+  return _internal_has_speedinmps();
+}
+inline void Message_LocationMessage::clear_speedinmps() {
+  _impl_.speedinmps_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline float Message_LocationMessage::_internal_speedinmps() const {
+  return _impl_.speedinmps_;
+}
+inline float Message_LocationMessage::speedinmps() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.speedInMps)
+  return _internal_speedinmps();
+}
+inline void Message_LocationMessage::_internal_set_speedinmps(float value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.speedinmps_ = value;
+}
+inline void Message_LocationMessage::set_speedinmps(float value) {
+  _internal_set_speedinmps(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.speedInMps)
+}
+
+// optional uint32 degreesClockwiseFromMagneticNorth = 9;
+inline bool Message_LocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_degreesclockwisefrommagneticnorth() const {
+  return _internal_has_degreesclockwisefrommagneticnorth();
+}
+inline void Message_LocationMessage::clear_degreesclockwisefrommagneticnorth() {
+  _impl_.degreesclockwisefrommagneticnorth_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline uint32_t Message_LocationMessage::_internal_degreesclockwisefrommagneticnorth() const {
+  return _impl_.degreesclockwisefrommagneticnorth_;
+}
+inline uint32_t Message_LocationMessage::degreesclockwisefrommagneticnorth() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth)
+  return _internal_degreesclockwisefrommagneticnorth();
+}
+inline void Message_LocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.degreesclockwisefrommagneticnorth_ = value;
+}
+inline void Message_LocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) {
+  _internal_set_degreesclockwisefrommagneticnorth(value);
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth)
+}
+
+// optional string comment = 11;
+inline bool Message_LocationMessage::_internal_has_comment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_comment() const {
+  return _internal_has_comment();
+}
+inline void Message_LocationMessage::clear_comment() {
+  _impl_.comment_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_LocationMessage::comment() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.comment)
+  return _internal_comment();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LocationMessage::set_comment(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.comment_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.comment)
+}
+inline std::string* Message_LocationMessage::mutable_comment() {
+  std::string* _s = _internal_mutable_comment();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.comment)
+  return _s;
+}
+inline const std::string& Message_LocationMessage::_internal_comment() const {
+  return _impl_.comment_.Get();
+}
+inline void Message_LocationMessage::_internal_set_comment(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.comment_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::_internal_mutable_comment() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.comment_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::release_comment() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.comment)
+  if (!_internal_has_comment()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.comment_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.comment_.IsDefault()) {
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LocationMessage::set_allocated_comment(std::string* comment) {
+  if (comment != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.comment_.SetAllocated(comment, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.comment_.IsDefault()) {
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.comment)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_LocationMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_LocationMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_LocationMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_LocationMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_LocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.jpegThumbnail)
+}
+inline std::string* Message_LocationMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_LocationMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_LocationMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_LocationMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_LocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_LocationMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_LocationMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_LocationMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ContextInfo& Message_LocationMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_LocationMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_LocationMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LocationMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_LocationMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_LocationMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_LocationMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_LocationMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.contextInfo)
+  return _msg;
+}
+inline void Message_LocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_OrderMessage
+
+// optional string orderId = 1;
+inline bool Message_OrderMessage::_internal_has_orderid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_orderid() const {
+  return _internal_has_orderid();
+}
+inline void Message_OrderMessage::clear_orderid() {
+  _impl_.orderid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_OrderMessage::orderid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderId)
+  return _internal_orderid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_orderid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.orderid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderId)
+}
+inline std::string* Message_OrderMessage::mutable_orderid() {
+  std::string* _s = _internal_mutable_orderid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderId)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_orderid() const {
+  return _impl_.orderid_.Get();
+}
+inline void Message_OrderMessage::_internal_set_orderid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.orderid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_orderid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.orderid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_orderid() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderId)
+  if (!_internal_has_orderid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.orderid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.orderid_.IsDefault()) {
+    _impl_.orderid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_orderid(std::string* orderid) {
+  if (orderid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.orderid_.SetAllocated(orderid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.orderid_.IsDefault()) {
+    _impl_.orderid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderId)
+}
+
+// optional bytes thumbnail = 2;
+inline bool Message_OrderMessage::_internal_has_thumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_thumbnail() const {
+  return _internal_has_thumbnail();
+}
+inline void Message_OrderMessage::clear_thumbnail() {
+  _impl_.thumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_OrderMessage::thumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.thumbnail)
+  return _internal_thumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_thumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.thumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.thumbnail)
+}
+inline std::string* Message_OrderMessage::mutable_thumbnail() {
+  std::string* _s = _internal_mutable_thumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.thumbnail)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_thumbnail() const {
+  return _impl_.thumbnail_.Get();
+}
+inline void Message_OrderMessage::_internal_set_thumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.thumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_thumbnail() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.thumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_thumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.thumbnail)
+  if (!_internal_has_thumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.thumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnail_.IsDefault()) {
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_thumbnail(std::string* thumbnail) {
+  if (thumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnail_.IsDefault()) {
+    _impl_.thumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.thumbnail)
+}
+
+// optional int32 itemCount = 3;
+inline bool Message_OrderMessage::_internal_has_itemcount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_itemcount() const {
+  return _internal_has_itemcount();
+}
+inline void Message_OrderMessage::clear_itemcount() {
+  _impl_.itemcount_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline int32_t Message_OrderMessage::_internal_itemcount() const {
+  return _impl_.itemcount_;
+}
+inline int32_t Message_OrderMessage::itemcount() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.itemCount)
+  return _internal_itemcount();
+}
+inline void Message_OrderMessage::_internal_set_itemcount(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.itemcount_ = value;
+}
+inline void Message_OrderMessage::set_itemcount(int32_t value) {
+  _internal_set_itemcount(value);
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.itemCount)
+}
+
+// optional .proto.Message.OrderMessage.OrderStatus status = 4;
+inline bool Message_OrderMessage::_internal_has_status() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_status() const {
+  return _internal_has_status();
+}
+inline void Message_OrderMessage::clear_status() {
+  _impl_.status_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::_internal_status() const {
+  return static_cast< ::proto::Message_OrderMessage_OrderStatus >(_impl_.status_);
+}
+inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::status() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.status)
+  return _internal_status();
+}
+inline void Message_OrderMessage::_internal_set_status(::proto::Message_OrderMessage_OrderStatus value) {
+  assert(::proto::Message_OrderMessage_OrderStatus_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.status_ = value;
+}
+inline void Message_OrderMessage::set_status(::proto::Message_OrderMessage_OrderStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.status)
+}
+
+// optional .proto.Message.OrderMessage.OrderSurface surface = 5;
+inline bool Message_OrderMessage::_internal_has_surface() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_surface() const {
+  return _internal_has_surface();
+}
+inline void Message_OrderMessage::clear_surface() {
+  _impl_.surface_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::_internal_surface() const {
+  return static_cast< ::proto::Message_OrderMessage_OrderSurface >(_impl_.surface_);
+}
+inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::surface() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.surface)
+  return _internal_surface();
+}
+inline void Message_OrderMessage::_internal_set_surface(::proto::Message_OrderMessage_OrderSurface value) {
+  assert(::proto::Message_OrderMessage_OrderSurface_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.surface_ = value;
+}
+inline void Message_OrderMessage::set_surface(::proto::Message_OrderMessage_OrderSurface value) {
+  _internal_set_surface(value);
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.surface)
+}
+
+// optional string message = 6;
+inline bool Message_OrderMessage::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_message() const {
+  return _internal_has_message();
+}
+inline void Message_OrderMessage::clear_message() {
+  _impl_.message_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_OrderMessage::message() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.message)
+  return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_message(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.message)
+}
+inline std::string* Message_OrderMessage::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.message)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_message() const {
+  return _impl_.message_.Get();
+}
+inline void Message_OrderMessage::_internal_set_message(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.message_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.message_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_message() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.message)
+  if (!_internal_has_message()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.message_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_message(std::string* message) {
+  if (message != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.message)
+}
+
+// optional string orderTitle = 7;
+inline bool Message_OrderMessage::_internal_has_ordertitle() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_ordertitle() const {
+  return _internal_has_ordertitle();
+}
+inline void Message_OrderMessage::clear_ordertitle() {
+  _impl_.ordertitle_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_OrderMessage::ordertitle() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderTitle)
+  return _internal_ordertitle();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_ordertitle(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.ordertitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderTitle)
+}
+inline std::string* Message_OrderMessage::mutable_ordertitle() {
+  std::string* _s = _internal_mutable_ordertitle();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderTitle)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_ordertitle() const {
+  return _impl_.ordertitle_.Get();
+}
+inline void Message_OrderMessage::_internal_set_ordertitle(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.ordertitle_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_ordertitle() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.ordertitle_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_ordertitle() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderTitle)
+  if (!_internal_has_ordertitle()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.ordertitle_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ordertitle_.IsDefault()) {
+    _impl_.ordertitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_ordertitle(std::string* ordertitle) {
+  if (ordertitle != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.ordertitle_.SetAllocated(ordertitle, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ordertitle_.IsDefault()) {
+    _impl_.ordertitle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderTitle)
+}
+
+// optional string sellerJid = 8;
+inline bool Message_OrderMessage::_internal_has_sellerjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_sellerjid() const {
+  return _internal_has_sellerjid();
+}
+inline void Message_OrderMessage::clear_sellerjid() {
+  _impl_.sellerjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_OrderMessage::sellerjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.sellerJid)
+  return _internal_sellerjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_sellerjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.sellerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.sellerJid)
+}
+inline std::string* Message_OrderMessage::mutable_sellerjid() {
+  std::string* _s = _internal_mutable_sellerjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.sellerJid)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_sellerjid() const {
+  return _impl_.sellerjid_.Get();
+}
+inline void Message_OrderMessage::_internal_set_sellerjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.sellerjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_sellerjid() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.sellerjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_sellerjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.sellerJid)
+  if (!_internal_has_sellerjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.sellerjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sellerjid_.IsDefault()) {
+    _impl_.sellerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_sellerjid(std::string* sellerjid) {
+  if (sellerjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.sellerjid_.SetAllocated(sellerjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sellerjid_.IsDefault()) {
+    _impl_.sellerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.sellerJid)
+}
+
+// optional string token = 9;
+inline bool Message_OrderMessage::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_token() const {
+  return _internal_has_token();
+}
+inline void Message_OrderMessage::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_OrderMessage::token() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.token)
+}
+inline std::string* Message_OrderMessage::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.token)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void Message_OrderMessage::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_token() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.token)
+}
+
+// optional int64 totalAmount1000 = 10;
+inline bool Message_OrderMessage::_internal_has_totalamount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_totalamount1000() const {
+  return _internal_has_totalamount1000();
+}
+inline void Message_OrderMessage::clear_totalamount1000() {
+  _impl_.totalamount1000_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline int64_t Message_OrderMessage::_internal_totalamount1000() const {
+  return _impl_.totalamount1000_;
+}
+inline int64_t Message_OrderMessage::totalamount1000() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalAmount1000)
+  return _internal_totalamount1000();
+}
+inline void Message_OrderMessage::_internal_set_totalamount1000(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.totalamount1000_ = value;
+}
+inline void Message_OrderMessage::set_totalamount1000(int64_t value) {
+  _internal_set_totalamount1000(value);
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalAmount1000)
+}
+
+// optional string totalCurrencyCode = 11;
+inline bool Message_OrderMessage::_internal_has_totalcurrencycode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_OrderMessage::has_totalcurrencycode() const {
+  return _internal_has_totalcurrencycode();
+}
+inline void Message_OrderMessage::clear_totalcurrencycode() {
+  _impl_.totalcurrencycode_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_OrderMessage::totalcurrencycode() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalCurrencyCode)
+  return _internal_totalcurrencycode();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_OrderMessage::set_totalcurrencycode(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.totalcurrencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalCurrencyCode)
+}
+inline std::string* Message_OrderMessage::mutable_totalcurrencycode() {
+  std::string* _s = _internal_mutable_totalcurrencycode();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.totalCurrencyCode)
+  return _s;
+}
+inline const std::string& Message_OrderMessage::_internal_totalcurrencycode() const {
+  return _impl_.totalcurrencycode_.Get();
+}
+inline void Message_OrderMessage::_internal_set_totalcurrencycode(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.totalcurrencycode_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::_internal_mutable_totalcurrencycode() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.totalcurrencycode_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_OrderMessage::release_totalcurrencycode() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.totalCurrencyCode)
+  if (!_internal_has_totalcurrencycode()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.totalcurrencycode_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.totalcurrencycode_.IsDefault()) {
+    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_OrderMessage::set_allocated_totalcurrencycode(std::string* totalcurrencycode) {
+  if (totalcurrencycode != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.totalcurrencycode_.SetAllocated(totalcurrencycode, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.totalcurrencycode_.IsDefault()) {
+    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.totalCurrencyCode)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_OrderMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_OrderMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_OrderMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::ContextInfo& Message_OrderMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_OrderMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_OrderMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.OrderMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_OrderMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_OrderMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_OrderMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_OrderMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.contextInfo)
+  return _msg;
+}
+inline void Message_OrderMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PaymentInviteMessage
+
+// optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
+inline bool Message_PaymentInviteMessage::_internal_has_servicetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_PaymentInviteMessage::has_servicetype() const {
+  return _internal_has_servicetype();
+}
+inline void Message_PaymentInviteMessage::clear_servicetype() {
+  _impl_.servicetype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::_internal_servicetype() const {
+  return static_cast< ::proto::Message_PaymentInviteMessage_ServiceType >(_impl_.servicetype_);
+}
+inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::servicetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.serviceType)
+  return _internal_servicetype();
+}
+inline void Message_PaymentInviteMessage::_internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) {
+  assert(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.servicetype_ = value;
+}
+inline void Message_PaymentInviteMessage::set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) {
+  _internal_set_servicetype(value);
+  // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.serviceType)
+}
+
+// optional int64 expiryTimestamp = 2;
+inline bool Message_PaymentInviteMessage::_internal_has_expirytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_PaymentInviteMessage::has_expirytimestamp() const {
+  return _internal_has_expirytimestamp();
+}
+inline void Message_PaymentInviteMessage::clear_expirytimestamp() {
+  _impl_.expirytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t Message_PaymentInviteMessage::_internal_expirytimestamp() const {
+  return _impl_.expirytimestamp_;
+}
+inline int64_t Message_PaymentInviteMessage::expirytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.expiryTimestamp)
+  return _internal_expirytimestamp();
+}
+inline void Message_PaymentInviteMessage::_internal_set_expirytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.expirytimestamp_ = value;
+}
+inline void Message_PaymentInviteMessage::set_expirytimestamp(int64_t value) {
+  _internal_set_expirytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.expiryTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PollCreationMessage_Option
+
+// optional string optionName = 1;
+inline bool Message_PollCreationMessage_Option::_internal_has_optionname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_PollCreationMessage_Option::has_optionname() const {
+  return _internal_has_optionname();
+}
+inline void Message_PollCreationMessage_Option::clear_optionname() {
+  _impl_.optionname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_PollCreationMessage_Option::optionname() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.Option.optionName)
+  return _internal_optionname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_PollCreationMessage_Option::set_optionname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.optionname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.Option.optionName)
+}
+inline std::string* Message_PollCreationMessage_Option::mutable_optionname() {
+  std::string* _s = _internal_mutable_optionname();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.Option.optionName)
+  return _s;
+}
+inline const std::string& Message_PollCreationMessage_Option::_internal_optionname() const {
+  return _impl_.optionname_.Get();
+}
+inline void Message_PollCreationMessage_Option::_internal_set_optionname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.optionname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage_Option::_internal_mutable_optionname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.optionname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage_Option::release_optionname() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.Option.optionName)
+  if (!_internal_has_optionname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.optionname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optionname_.IsDefault()) {
+    _impl_.optionname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_PollCreationMessage_Option::set_allocated_optionname(std::string* optionname) {
+  if (optionname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.optionname_.SetAllocated(optionname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optionname_.IsDefault()) {
+    _impl_.optionname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.Option.optionName)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PollCreationMessage
+
+// optional bytes encKey = 1;
+inline bool Message_PollCreationMessage::_internal_has_enckey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_PollCreationMessage::has_enckey() const {
+  return _internal_has_enckey();
+}
+inline void Message_PollCreationMessage::clear_enckey() {
+  _impl_.enckey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_PollCreationMessage::enckey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.encKey)
+  return _internal_enckey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_PollCreationMessage::set_enckey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.enckey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.encKey)
+}
+inline std::string* Message_PollCreationMessage::mutable_enckey() {
+  std::string* _s = _internal_mutable_enckey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.encKey)
+  return _s;
+}
+inline const std::string& Message_PollCreationMessage::_internal_enckey() const {
+  return _impl_.enckey_.Get();
+}
+inline void Message_PollCreationMessage::_internal_set_enckey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.enckey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage::_internal_mutable_enckey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.enckey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage::release_enckey() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.encKey)
+  if (!_internal_has_enckey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.enckey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enckey_.IsDefault()) {
+    _impl_.enckey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_PollCreationMessage::set_allocated_enckey(std::string* enckey) {
+  if (enckey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.enckey_.SetAllocated(enckey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enckey_.IsDefault()) {
+    _impl_.enckey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.encKey)
+}
+
+// optional string name = 2;
+inline bool Message_PollCreationMessage::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_PollCreationMessage::has_name() const {
+  return _internal_has_name();
+}
+inline void Message_PollCreationMessage::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_PollCreationMessage::name() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_PollCreationMessage::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.name)
+}
+inline std::string* Message_PollCreationMessage::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.name)
+  return _s;
+}
+inline const std::string& Message_PollCreationMessage::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Message_PollCreationMessage::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_PollCreationMessage::release_name() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_PollCreationMessage::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.name)
+}
+
+// repeated .proto.Message.PollCreationMessage.Option options = 3;
+inline int Message_PollCreationMessage::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Message_PollCreationMessage::options_size() const {
+  return _internal_options_size();
+}
+inline void Message_PollCreationMessage::clear_options() {
+  _impl_.options_.Clear();
+}
+inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >*
+Message_PollCreationMessage::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.PollCreationMessage.options)
+  return &_impl_.options_;
+}
+inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::options(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.options)
+  return _internal_options(index);
+}
+inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::add_options() {
+  ::proto::Message_PollCreationMessage_Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:proto.Message.PollCreationMessage.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >&
+Message_PollCreationMessage::options() const {
+  // @@protoc_insertion_point(field_list:proto.Message.PollCreationMessage.options)
+  return _impl_.options_;
+}
+
+// optional uint32 selectableOptionsCount = 4;
+inline bool Message_PollCreationMessage::_internal_has_selectableoptionscount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_PollCreationMessage::has_selectableoptionscount() const {
+  return _internal_has_selectableoptionscount();
+}
+inline void Message_PollCreationMessage::clear_selectableoptionscount() {
+  _impl_.selectableoptionscount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t Message_PollCreationMessage::_internal_selectableoptionscount() const {
+  return _impl_.selectableoptionscount_;
+}
+inline uint32_t Message_PollCreationMessage::selectableoptionscount() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.selectableOptionsCount)
+  return _internal_selectableoptionscount();
+}
+inline void Message_PollCreationMessage::_internal_set_selectableoptionscount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.selectableoptionscount_ = value;
+}
+inline void Message_PollCreationMessage::set_selectableoptionscount(uint32_t value) {
+  _internal_set_selectableoptionscount(value);
+  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.selectableOptionsCount)
+}
+
+// optional .proto.ContextInfo contextInfo = 5;
+inline bool Message_PollCreationMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_PollCreationMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_PollCreationMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ContextInfo& Message_PollCreationMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_PollCreationMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_PollCreationMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollCreationMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_PollCreationMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_PollCreationMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_PollCreationMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_PollCreationMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.contextInfo)
+  return _msg;
+}
+inline void Message_PollCreationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PollEncValue
+
+// optional bytes encPayload = 1;
+inline bool Message_PollEncValue::_internal_has_encpayload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_PollEncValue::has_encpayload() const {
+  return _internal_has_encpayload();
+}
+inline void Message_PollEncValue::clear_encpayload() {
+  _impl_.encpayload_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_PollEncValue::encpayload() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encPayload)
+  return _internal_encpayload();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.encpayload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encPayload)
+}
+inline std::string* Message_PollEncValue::mutable_encpayload() {
+  std::string* _s = _internal_mutable_encpayload();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encPayload)
+  return _s;
+}
+inline const std::string& Message_PollEncValue::_internal_encpayload() const {
+  return _impl_.encpayload_.Get();
+}
+inline void Message_PollEncValue::_internal_set_encpayload(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.encpayload_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_PollEncValue::_internal_mutable_encpayload() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.encpayload_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_PollEncValue::release_encpayload() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encPayload)
+  if (!_internal_has_encpayload()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.encpayload_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encpayload_.IsDefault()) {
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_PollEncValue::set_allocated_encpayload(std::string* encpayload) {
+  if (encpayload != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encpayload_.IsDefault()) {
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encPayload)
+}
+
+// optional bytes encIv = 2;
+inline bool Message_PollEncValue::_internal_has_enciv() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_PollEncValue::has_enciv() const {
+  return _internal_has_enciv();
+}
+inline void Message_PollEncValue::clear_enciv() {
+  _impl_.enciv_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_PollEncValue::enciv() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encIv)
+  return _internal_enciv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.enciv_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encIv)
+}
+inline std::string* Message_PollEncValue::mutable_enciv() {
+  std::string* _s = _internal_mutable_enciv();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encIv)
+  return _s;
+}
+inline const std::string& Message_PollEncValue::_internal_enciv() const {
+  return _impl_.enciv_.Get();
+}
+inline void Message_PollEncValue::_internal_set_enciv(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.enciv_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_PollEncValue::_internal_mutable_enciv() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.enciv_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_PollEncValue::release_enciv() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encIv)
+  if (!_internal_has_enciv()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.enciv_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enciv_.IsDefault()) {
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_PollEncValue::set_allocated_enciv(std::string* enciv) {
+  if (enciv != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enciv_.IsDefault()) {
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encIv)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PollUpdateMessageMetadata
+
+// -------------------------------------------------------------------
+
+// Message_PollUpdateMessage
+
+// optional .proto.MessageKey pollCreationMessageKey = 1;
+inline bool Message_PollUpdateMessage::_internal_has_pollcreationmessagekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pollcreationmessagekey_ != nullptr);
+  return value;
+}
+inline bool Message_PollUpdateMessage::has_pollcreationmessagekey() const {
+  return _internal_has_pollcreationmessagekey();
+}
+inline void Message_PollUpdateMessage::clear_pollcreationmessagekey() {
+  if (_impl_.pollcreationmessagekey_ != nullptr) _impl_.pollcreationmessagekey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& Message_PollUpdateMessage::_internal_pollcreationmessagekey() const {
+  const ::proto::MessageKey* p = _impl_.pollcreationmessagekey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_PollUpdateMessage::pollcreationmessagekey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.pollCreationMessageKey)
+  return _internal_pollcreationmessagekey();
+}
+inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_pollcreationmessagekey(
+    ::proto::MessageKey* pollcreationmessagekey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessagekey_);
+  }
+  _impl_.pollcreationmessagekey_ = pollcreationmessagekey;
+  if (pollcreationmessagekey) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey)
+}
+inline ::proto::MessageKey* Message_PollUpdateMessage::release_pollcreationmessagekey() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_;
+  _impl_.pollcreationmessagekey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_PollUpdateMessage::unsafe_arena_release_pollcreationmessagekey() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.pollCreationMessageKey)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_;
+  _impl_.pollcreationmessagekey_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_PollUpdateMessage::_internal_mutable_pollcreationmessagekey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.pollcreationmessagekey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.pollcreationmessagekey_ = p;
+  }
+  return _impl_.pollcreationmessagekey_;
+}
+inline ::proto::MessageKey* Message_PollUpdateMessage::mutable_pollcreationmessagekey() {
+  ::proto::MessageKey* _msg = _internal_mutable_pollcreationmessagekey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.pollCreationMessageKey)
+  return _msg;
+}
+inline void Message_PollUpdateMessage::set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pollcreationmessagekey_;
+  }
+  if (pollcreationmessagekey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessagekey);
+    if (message_arena != submessage_arena) {
+      pollcreationmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pollcreationmessagekey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.pollcreationmessagekey_ = pollcreationmessagekey;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey)
+}
+
+// optional .proto.Message.PollEncValue vote = 2;
+inline bool Message_PollUpdateMessage::_internal_has_vote() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr);
+  return value;
+}
+inline bool Message_PollUpdateMessage::has_vote() const {
+  return _internal_has_vote();
+}
+inline void Message_PollUpdateMessage::clear_vote() {
+  if (_impl_.vote_ != nullptr) _impl_.vote_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::_internal_vote() const {
+  const ::proto::Message_PollEncValue* p = _impl_.vote_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollEncValue&>(
+      ::proto::_Message_PollEncValue_default_instance_);
+}
+inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::vote() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.vote)
+  return _internal_vote();
+}
+inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_vote(
+    ::proto::Message_PollEncValue* vote) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_);
+  }
+  _impl_.vote_ = vote;
+  if (vote) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.vote)
+}
+inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::release_vote() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_PollEncValue* temp = _impl_.vote_;
+  _impl_.vote_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::unsafe_arena_release_vote() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.vote)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_PollEncValue* temp = _impl_.vote_;
+  _impl_.vote_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::_internal_mutable_vote() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.vote_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PollEncValue>(GetArenaForAllocation());
+    _impl_.vote_ = p;
+  }
+  return _impl_.vote_;
+}
+inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::mutable_vote() {
+  ::proto::Message_PollEncValue* _msg = _internal_mutable_vote();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.vote)
+  return _msg;
+}
+inline void Message_PollUpdateMessage::set_allocated_vote(::proto::Message_PollEncValue* vote) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.vote_;
+  }
+  if (vote) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote);
+    if (message_arena != submessage_arena) {
+      vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, vote, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.vote_ = vote;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.vote)
+}
+
+// optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
+inline bool Message_PollUpdateMessage::_internal_has_metadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr);
+  return value;
+}
+inline bool Message_PollUpdateMessage::has_metadata() const {
+  return _internal_has_metadata();
+}
+inline void Message_PollUpdateMessage::clear_metadata() {
+  if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::_internal_metadata() const {
+  const ::proto::Message_PollUpdateMessageMetadata* p = _impl_.metadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollUpdateMessageMetadata&>(
+      ::proto::_Message_PollUpdateMessageMetadata_default_instance_);
+}
+inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::metadata() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.metadata)
+  return _internal_metadata();
+}
+inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_metadata(
+    ::proto::Message_PollUpdateMessageMetadata* metadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
+  }
+  _impl_.metadata_ = metadata;
+  if (metadata) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.metadata)
+}
+inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::release_metadata() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_;
+  _impl_.metadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::unsafe_arena_release_metadata() {
+  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.metadata)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_;
+  _impl_.metadata_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::_internal_mutable_metadata() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.metadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(GetArenaForAllocation());
+    _impl_.metadata_ = p;
+  }
+  return _impl_.metadata_;
+}
+inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::mutable_metadata() {
+  ::proto::Message_PollUpdateMessageMetadata* _msg = _internal_mutable_metadata();
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.metadata)
+  return _msg;
+}
+inline void Message_PollUpdateMessage::set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.metadata_;
+  }
+  if (metadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
+    if (message_arena != submessage_arena) {
+      metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, metadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.metadata_ = metadata;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.metadata)
+}
+
+// optional int64 senderTimestampMs = 4;
+inline bool Message_PollUpdateMessage::_internal_has_sendertimestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_PollUpdateMessage::has_sendertimestampms() const {
+  return _internal_has_sendertimestampms();
+}
+inline void Message_PollUpdateMessage::clear_sendertimestampms() {
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t Message_PollUpdateMessage::_internal_sendertimestampms() const {
+  return _impl_.sendertimestampms_;
+}
+inline int64_t Message_PollUpdateMessage::sendertimestampms() const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.senderTimestampMs)
+  return _internal_sendertimestampms();
+}
+inline void Message_PollUpdateMessage::_internal_set_sendertimestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.sendertimestampms_ = value;
+}
+inline void Message_PollUpdateMessage::set_sendertimestampms(int64_t value) {
+  _internal_set_sendertimestampms(value);
+  // @@protoc_insertion_point(field_set:proto.Message.PollUpdateMessage.senderTimestampMs)
+}
+
+// -------------------------------------------------------------------
+
+// Message_PollVoteMessage
+
+// repeated bytes selectedOptions = 1;
+inline int Message_PollVoteMessage::_internal_selectedoptions_size() const {
+  return _impl_.selectedoptions_.size();
+}
+inline int Message_PollVoteMessage::selectedoptions_size() const {
+  return _internal_selectedoptions_size();
+}
+inline void Message_PollVoteMessage::clear_selectedoptions() {
+  _impl_.selectedoptions_.Clear();
+}
+inline std::string* Message_PollVoteMessage::add_selectedoptions() {
+  std::string* _s = _internal_add_selectedoptions();
+  // @@protoc_insertion_point(field_add_mutable:proto.Message.PollVoteMessage.selectedOptions)
+  return _s;
+}
+inline const std::string& Message_PollVoteMessage::_internal_selectedoptions(int index) const {
+  return _impl_.selectedoptions_.Get(index);
+}
+inline const std::string& Message_PollVoteMessage::selectedoptions(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.PollVoteMessage.selectedOptions)
+  return _internal_selectedoptions(index);
+}
+inline std::string* Message_PollVoteMessage::mutable_selectedoptions(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.PollVoteMessage.selectedOptions)
+  return _impl_.selectedoptions_.Mutable(index);
+}
+inline void Message_PollVoteMessage::set_selectedoptions(int index, const std::string& value) {
+  _impl_.selectedoptions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::set_selectedoptions(int index, std::string&& value) {
+  _impl_.selectedoptions_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::set_selectedoptions(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.selectedoptions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::set_selectedoptions(int index, const void* value, size_t size) {
+  _impl_.selectedoptions_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline std::string* Message_PollVoteMessage::_internal_add_selectedoptions() {
+  return _impl_.selectedoptions_.Add();
+}
+inline void Message_PollVoteMessage::add_selectedoptions(const std::string& value) {
+  _impl_.selectedoptions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::add_selectedoptions(std::string&& value) {
+  _impl_.selectedoptions_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::add_selectedoptions(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.selectedoptions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline void Message_PollVoteMessage::add_selectedoptions(const void* value, size_t size) {
+  _impl_.selectedoptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.Message.PollVoteMessage.selectedOptions)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Message_PollVoteMessage::selectedoptions() const {
+  // @@protoc_insertion_point(field_list:proto.Message.PollVoteMessage.selectedOptions)
+  return _impl_.selectedoptions_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Message_PollVoteMessage::mutable_selectedoptions() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.PollVoteMessage.selectedOptions)
+  return &_impl_.selectedoptions_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_ProductMessage_CatalogSnapshot
+
+// optional .proto.Message.ImageMessage catalogImage = 1;
+inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_catalogimage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.catalogimage_ != nullptr);
+  return value;
+}
+inline bool Message_ProductMessage_CatalogSnapshot::has_catalogimage() const {
+  return _internal_has_catalogimage();
+}
+inline void Message_ProductMessage_CatalogSnapshot::clear_catalogimage() {
+  if (_impl_.catalogimage_ != nullptr) _impl_.catalogimage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::_internal_catalogimage() const {
+  const ::proto::Message_ImageMessage* p = _impl_.catalogimage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
+      ::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::catalogimage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
+  return _internal_catalogimage();
+}
+inline void Message_ProductMessage_CatalogSnapshot::unsafe_arena_set_allocated_catalogimage(
+    ::proto::Message_ImageMessage* catalogimage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalogimage_);
+  }
+  _impl_.catalogimage_ = catalogimage;
+  if (catalogimage) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::release_catalogimage() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ImageMessage* temp = _impl_.catalogimage_;
+  _impl_.catalogimage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::unsafe_arena_release_catalogimage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ImageMessage* temp = _impl_.catalogimage_;
+  _impl_.catalogimage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::_internal_mutable_catalogimage() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.catalogimage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
+    _impl_.catalogimage_ = p;
+  }
+  return _impl_.catalogimage_;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::mutable_catalogimage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_catalogimage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
+  return _msg;
+}
+inline void Message_ProductMessage_CatalogSnapshot::set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.catalogimage_;
+  }
+  if (catalogimage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalogimage);
+    if (message_arena != submessage_arena) {
+      catalogimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, catalogimage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.catalogimage_ = catalogimage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
+}
+
+// optional string title = 2;
+inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_CatalogSnapshot::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ProductMessage_CatalogSnapshot::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ProductMessage_CatalogSnapshot::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_CatalogSnapshot::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.title)
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.title)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ProductMessage_CatalogSnapshot::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_CatalogSnapshot::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.title)
+}
+
+// optional string description = 3;
+inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_CatalogSnapshot::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ProductMessage_CatalogSnapshot::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ProductMessage_CatalogSnapshot::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_CatalogSnapshot::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.description)
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.description)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ProductMessage_CatalogSnapshot::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_CatalogSnapshot::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_CatalogSnapshot::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.description)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ProductMessage_ProductSnapshot
+
+// optional .proto.Message.ImageMessage productImage = 1;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.productimage_ != nullptr);
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_productimage() const {
+  return _internal_has_productimage();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_productimage() {
+  if (_impl_.productimage_ != nullptr) _impl_.productimage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::_internal_productimage() const {
+  const ::proto::Message_ImageMessage* p = _impl_.productimage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
+      ::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::productimage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImage)
+  return _internal_productimage();
+}
+inline void Message_ProductMessage_ProductSnapshot::unsafe_arena_set_allocated_productimage(
+    ::proto::Message_ImageMessage* productimage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productimage_);
+  }
+  _impl_.productimage_ = productimage;
+  if (productimage) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage)
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::release_productimage() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_ImageMessage* temp = _impl_.productimage_;
+  _impl_.productimage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::unsafe_arena_release_productimage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productImage)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_ImageMessage* temp = _impl_.productimage_;
+  _impl_.productimage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::_internal_mutable_productimage() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.productimage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
+    _impl_.productimage_ = p;
+  }
+  return _impl_.productimage_;
+}
+inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::mutable_productimage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_productimage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productImage)
+  return _msg;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_productimage(::proto::Message_ImageMessage* productimage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.productimage_;
+  }
+  if (productimage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productimage);
+    if (message_arena != submessage_arena) {
+      productimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, productimage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.productimage_ = productimage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage)
+}
+
+// optional string productId = 2;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_productid() const {
+  return _internal_has_productid();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_productid() {
+  _impl_.productid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::productid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productId)
+  return _internal_productid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_productid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productId)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_productid() {
+  std::string* _s = _internal_mutable_productid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productId)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_productid() const {
+  return _impl_.productid_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_productid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.productid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_productid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.productid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_productid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productId)
+  if (!_internal_has_productid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.productid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_productid(std::string* productid) {
+  if (productid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.productid_.IsDefault()) {
+    _impl_.productid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productId)
+}
+
+// optional string title = 3;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_title() const {
+  return _internal_has_title();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::title() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.title)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.title)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_title() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.title)
+}
+
+// optional string description = 4;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_description() const {
+  return _internal_has_description();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::description() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.description)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.description)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_description() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.description)
+}
+
+// optional string currencyCode = 5;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_currencycode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_currencycode() const {
+  return _internal_has_currencycode();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_currencycode() {
+  _impl_.currencycode_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::currencycode() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
+  return _internal_currencycode();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_currencycode(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_currencycode() {
+  std::string* _s = _internal_mutable_currencycode();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_currencycode() const {
+  return _impl_.currencycode_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_currencycode(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.currencycode_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_currencycode() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_currencycode() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
+  if (!_internal_has_currencycode()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.currencycode_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_currencycode(std::string* currencycode) {
+  if (currencycode != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
+}
+
+// optional int64 priceAmount1000 = 6;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_priceamount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_priceamount1000() const {
+  return _internal_has_priceamount1000();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_priceamount1000() {
+  _impl_.priceamount1000_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline int64_t Message_ProductMessage_ProductSnapshot::_internal_priceamount1000() const {
+  return _impl_.priceamount1000_;
+}
+inline int64_t Message_ProductMessage_ProductSnapshot::priceamount1000() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000)
+  return _internal_priceamount1000();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_priceamount1000(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.priceamount1000_ = value;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_priceamount1000(int64_t value) {
+  _internal_set_priceamount1000(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000)
+}
+
+// optional string retailerId = 7;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_retailerid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_retailerid() const {
+  return _internal_has_retailerid();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_retailerid() {
+  _impl_.retailerid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::retailerid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.retailerId)
+  return _internal_retailerid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_retailerid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.retailerid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.retailerId)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_retailerid() {
+  std::string* _s = _internal_mutable_retailerid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.retailerId)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_retailerid() const {
+  return _impl_.retailerid_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_retailerid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.retailerid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_retailerid() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.retailerid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_retailerid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.retailerId)
+  if (!_internal_has_retailerid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.retailerid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.retailerid_.IsDefault()) {
+    _impl_.retailerid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_retailerid(std::string* retailerid) {
+  if (retailerid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.retailerid_.SetAllocated(retailerid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.retailerid_.IsDefault()) {
+    _impl_.retailerid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.retailerId)
+}
+
+// optional string url = 8;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.url)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.url)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.url)
+}
+
+// optional uint32 productImageCount = 9;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimagecount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_productimagecount() const {
+  return _internal_has_productimagecount();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_productimagecount() {
+  _impl_.productimagecount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline uint32_t Message_ProductMessage_ProductSnapshot::_internal_productimagecount() const {
+  return _impl_.productimagecount_;
+}
+inline uint32_t Message_ProductMessage_ProductSnapshot::productimagecount() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImageCount)
+  return _internal_productimagecount();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_productimagecount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.productimagecount_ = value;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_productimagecount(uint32_t value) {
+  _internal_set_productimagecount(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productImageCount)
+}
+
+// optional string firstImageId = 11;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_firstimageid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_firstimageid() const {
+  return _internal_has_firstimageid();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_firstimageid() {
+  _impl_.firstimageid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::firstimageid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
+  return _internal_firstimageid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage_ProductSnapshot::set_firstimageid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.firstimageid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::mutable_firstimageid() {
+  std::string* _s = _internal_mutable_firstimageid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
+  return _s;
+}
+inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_firstimageid() const {
+  return _impl_.firstimageid_.Get();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_firstimageid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.firstimageid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_firstimageid() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.firstimageid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage_ProductSnapshot::release_firstimageid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
+  if (!_internal_has_firstimageid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.firstimageid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstimageid_.IsDefault()) {
+    _impl_.firstimageid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_allocated_firstimageid(std::string* firstimageid) {
+  if (firstimageid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.firstimageid_.SetAllocated(firstimageid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstimageid_.IsDefault()) {
+    _impl_.firstimageid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
+}
+
+// optional int64 salePriceAmount1000 = 12;
+inline bool Message_ProductMessage_ProductSnapshot::_internal_has_salepriceamount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage_ProductSnapshot::has_salepriceamount1000() const {
+  return _internal_has_salepriceamount1000();
+}
+inline void Message_ProductMessage_ProductSnapshot::clear_salepriceamount1000() {
+  _impl_.salepriceamount1000_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline int64_t Message_ProductMessage_ProductSnapshot::_internal_salepriceamount1000() const {
+  return _impl_.salepriceamount1000_;
+}
+inline int64_t Message_ProductMessage_ProductSnapshot::salepriceamount1000() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000)
+  return _internal_salepriceamount1000();
+}
+inline void Message_ProductMessage_ProductSnapshot::_internal_set_salepriceamount1000(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.salepriceamount1000_ = value;
+}
+inline void Message_ProductMessage_ProductSnapshot::set_salepriceamount1000(int64_t value) {
+  _internal_set_salepriceamount1000(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ProductMessage
+
+// optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
+inline bool Message_ProductMessage::_internal_has_product() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.product_ != nullptr);
+  return value;
+}
+inline bool Message_ProductMessage::has_product() const {
+  return _internal_has_product();
+}
+inline void Message_ProductMessage::clear_product() {
+  if (_impl_.product_ != nullptr) _impl_.product_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::_internal_product() const {
+  const ::proto::Message_ProductMessage_ProductSnapshot* p = _impl_.product_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage_ProductSnapshot&>(
+      ::proto::_Message_ProductMessage_ProductSnapshot_default_instance_);
+}
+inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::product() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.product)
+  return _internal_product();
+}
+inline void Message_ProductMessage::unsafe_arena_set_allocated_product(
+    ::proto::Message_ProductMessage_ProductSnapshot* product) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.product_);
+  }
+  _impl_.product_ = product;
+  if (product) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.product)
+}
+inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::release_product() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_;
+  _impl_.product_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::unsafe_arena_release_product() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.product)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_;
+  _impl_.product_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::_internal_mutable_product() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.product_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(GetArenaForAllocation());
+    _impl_.product_ = p;
+  }
+  return _impl_.product_;
+}
+inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::mutable_product() {
+  ::proto::Message_ProductMessage_ProductSnapshot* _msg = _internal_mutable_product();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.product)
+  return _msg;
+}
+inline void Message_ProductMessage::set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.product_;
+  }
+  if (product) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(product);
+    if (message_arena != submessage_arena) {
+      product = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, product, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.product_ = product;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.product)
+}
+
+// optional string businessOwnerJid = 2;
+inline bool Message_ProductMessage::_internal_has_businessownerjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage::has_businessownerjid() const {
+  return _internal_has_businessownerjid();
+}
+inline void Message_ProductMessage::clear_businessownerjid() {
+  _impl_.businessownerjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ProductMessage::businessownerjid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.businessOwnerJid)
+  return _internal_businessownerjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage::set_businessownerjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.businessownerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.businessOwnerJid)
+}
+inline std::string* Message_ProductMessage::mutable_businessownerjid() {
+  std::string* _s = _internal_mutable_businessownerjid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.businessOwnerJid)
+  return _s;
+}
+inline const std::string& Message_ProductMessage::_internal_businessownerjid() const {
+  return _impl_.businessownerjid_.Get();
+}
+inline void Message_ProductMessage::_internal_set_businessownerjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.businessownerjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::_internal_mutable_businessownerjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.businessownerjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::release_businessownerjid() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.businessOwnerJid)
+  if (!_internal_has_businessownerjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.businessownerjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.businessownerjid_.IsDefault()) {
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage::set_allocated_businessownerjid(std::string* businessownerjid) {
+  if (businessownerjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.businessownerjid_.IsDefault()) {
+    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.businessOwnerJid)
+}
+
+// optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
+inline bool Message_ProductMessage::_internal_has_catalog() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.catalog_ != nullptr);
+  return value;
+}
+inline bool Message_ProductMessage::has_catalog() const {
+  return _internal_has_catalog();
+}
+inline void Message_ProductMessage::clear_catalog() {
+  if (_impl_.catalog_ != nullptr) _impl_.catalog_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::_internal_catalog() const {
+  const ::proto::Message_ProductMessage_CatalogSnapshot* p = _impl_.catalog_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage_CatalogSnapshot&>(
+      ::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_);
+}
+inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::catalog() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.catalog)
+  return _internal_catalog();
+}
+inline void Message_ProductMessage::unsafe_arena_set_allocated_catalog(
+    ::proto::Message_ProductMessage_CatalogSnapshot* catalog) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalog_);
+  }
+  _impl_.catalog_ = catalog;
+  if (catalog) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.catalog)
+}
+inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::release_catalog() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_;
+  _impl_.catalog_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::unsafe_arena_release_catalog() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.catalog)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_;
+  _impl_.catalog_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::_internal_mutable_catalog() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.catalog_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(GetArenaForAllocation());
+    _impl_.catalog_ = p;
+  }
+  return _impl_.catalog_;
+}
+inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::mutable_catalog() {
+  ::proto::Message_ProductMessage_CatalogSnapshot* _msg = _internal_mutable_catalog();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.catalog)
+  return _msg;
+}
+inline void Message_ProductMessage::set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.catalog_;
+  }
+  if (catalog) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalog);
+    if (message_arena != submessage_arena) {
+      catalog = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, catalog, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.catalog_ = catalog;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.catalog)
+}
+
+// optional string body = 5;
+inline bool Message_ProductMessage::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage::has_body() const {
+  return _internal_has_body();
+}
+inline void Message_ProductMessage::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ProductMessage::body() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.body)
+}
+inline std::string* Message_ProductMessage::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.body)
+  return _s;
+}
+inline const std::string& Message_ProductMessage::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void Message_ProductMessage::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::release_body() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.body)
+}
+
+// optional string footer = 6;
+inline bool Message_ProductMessage::_internal_has_footer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_ProductMessage::has_footer() const {
+  return _internal_has_footer();
+}
+inline void Message_ProductMessage::clear_footer() {
+  _impl_.footer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_ProductMessage::footer() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.footer)
+  return _internal_footer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ProductMessage::set_footer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.footer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.footer)
+}
+inline std::string* Message_ProductMessage::mutable_footer() {
+  std::string* _s = _internal_mutable_footer();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.footer)
+  return _s;
+}
+inline const std::string& Message_ProductMessage::_internal_footer() const {
+  return _impl_.footer_.Get();
+}
+inline void Message_ProductMessage::_internal_set_footer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.footer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::_internal_mutable_footer() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.footer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ProductMessage::release_footer() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.footer)
+  if (!_internal_has_footer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.footer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footer_.IsDefault()) {
+    _impl_.footer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ProductMessage::set_allocated_footer(std::string* footer) {
+  if (footer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.footer_.SetAllocated(footer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.footer_.IsDefault()) {
+    _impl_.footer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.footer)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_ProductMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_ProductMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_ProductMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ContextInfo& Message_ProductMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_ProductMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_ProductMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_ProductMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ProductMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_ProductMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_ProductMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.contextInfo)
+  return _msg;
+}
+inline void Message_ProductMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ProtocolMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool Message_ProtocolMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void Message_ProtocolMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& Message_ProtocolMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_ProtocolMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.key)
+  return _internal_key();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.key)
+}
+inline ::proto::MessageKey* Message_ProtocolMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_ProtocolMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_ProtocolMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Message_ProtocolMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.key)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.key)
+}
+
+// optional .proto.Message.ProtocolMessage.Type type = 2;
+inline bool Message_ProtocolMessage::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_ProtocolMessage::has_type() const {
+  return _internal_has_type();
+}
+inline void Message_ProtocolMessage::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::_internal_type() const {
+  return static_cast< ::proto::Message_ProtocolMessage_Type >(_impl_.type_);
+}
+inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::type() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.type)
+  return _internal_type();
+}
+inline void Message_ProtocolMessage::_internal_set_type(::proto::Message_ProtocolMessage_Type value) {
+  assert(::proto::Message_ProtocolMessage_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.type_ = value;
+}
+inline void Message_ProtocolMessage::set_type(::proto::Message_ProtocolMessage_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.type)
+}
+
+// optional uint32 ephemeralExpiration = 4;
+inline bool Message_ProtocolMessage::_internal_has_ephemeralexpiration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_ProtocolMessage::has_ephemeralexpiration() const {
+  return _internal_has_ephemeralexpiration();
+}
+inline void Message_ProtocolMessage::clear_ephemeralexpiration() {
+  _impl_.ephemeralexpiration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline uint32_t Message_ProtocolMessage::_internal_ephemeralexpiration() const {
+  return _impl_.ephemeralexpiration_;
+}
+inline uint32_t Message_ProtocolMessage::ephemeralexpiration() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralExpiration)
+  return _internal_ephemeralexpiration();
+}
+inline void Message_ProtocolMessage::_internal_set_ephemeralexpiration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.ephemeralexpiration_ = value;
+}
+inline void Message_ProtocolMessage::set_ephemeralexpiration(uint32_t value) {
+  _internal_set_ephemeralexpiration(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralExpiration)
+}
+
+// optional int64 ephemeralSettingTimestamp = 5;
+inline bool Message_ProtocolMessage::_internal_has_ephemeralsettingtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_ProtocolMessage::has_ephemeralsettingtimestamp() const {
+  return _internal_has_ephemeralsettingtimestamp();
+}
+inline void Message_ProtocolMessage::clear_ephemeralsettingtimestamp() {
+  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline int64_t Message_ProtocolMessage::_internal_ephemeralsettingtimestamp() const {
+  return _impl_.ephemeralsettingtimestamp_;
+}
+inline int64_t Message_ProtocolMessage::ephemeralsettingtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralSettingTimestamp)
+  return _internal_ephemeralsettingtimestamp();
+}
+inline void Message_ProtocolMessage::_internal_set_ephemeralsettingtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.ephemeralsettingtimestamp_ = value;
+}
+inline void Message_ProtocolMessage::set_ephemeralsettingtimestamp(int64_t value) {
+  _internal_set_ephemeralsettingtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralSettingTimestamp)
+}
+
+// optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
+inline bool Message_ProtocolMessage::_internal_has_historysyncnotification() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.historysyncnotification_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_historysyncnotification() const {
+  return _internal_has_historysyncnotification();
+}
+inline void Message_ProtocolMessage::clear_historysyncnotification() {
+  if (_impl_.historysyncnotification_ != nullptr) _impl_.historysyncnotification_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::_internal_historysyncnotification() const {
+  const ::proto::Message_HistorySyncNotification* p = _impl_.historysyncnotification_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HistorySyncNotification&>(
+      ::proto::_Message_HistorySyncNotification_default_instance_);
+}
+inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::historysyncnotification() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.historySyncNotification)
+  return _internal_historysyncnotification();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_historysyncnotification(
+    ::proto::Message_HistorySyncNotification* historysyncnotification) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.historysyncnotification_);
+  }
+  _impl_.historysyncnotification_ = historysyncnotification;
+  if (historysyncnotification) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.historySyncNotification)
+}
+inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::release_historysyncnotification() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_;
+  _impl_.historysyncnotification_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::unsafe_arena_release_historysyncnotification() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.historySyncNotification)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_;
+  _impl_.historysyncnotification_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::_internal_mutable_historysyncnotification() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.historysyncnotification_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HistorySyncNotification>(GetArenaForAllocation());
+    _impl_.historysyncnotification_ = p;
+  }
+  return _impl_.historysyncnotification_;
+}
+inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::mutable_historysyncnotification() {
+  ::proto::Message_HistorySyncNotification* _msg = _internal_mutable_historysyncnotification();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.historySyncNotification)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.historysyncnotification_;
+  }
+  if (historysyncnotification) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(historysyncnotification);
+    if (message_arena != submessage_arena) {
+      historysyncnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, historysyncnotification, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.historysyncnotification_ = historysyncnotification;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.historySyncNotification)
+}
+
+// optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyshare() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyshare_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_appstatesynckeyshare() const {
+  return _internal_has_appstatesynckeyshare();
+}
+inline void Message_ProtocolMessage::clear_appstatesynckeyshare() {
+  if (_impl_.appstatesynckeyshare_ != nullptr) _impl_.appstatesynckeyshare_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::_internal_appstatesynckeyshare() const {
+  const ::proto::Message_AppStateSyncKeyShare* p = _impl_.appstatesynckeyshare_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyShare&>(
+      ::proto::_Message_AppStateSyncKeyShare_default_instance_);
+}
+inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::appstatesynckeyshare() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyShare)
+  return _internal_appstatesynckeyshare();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyshare(
+    ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyshare_);
+  }
+  _impl_.appstatesynckeyshare_ = appstatesynckeyshare;
+  if (appstatesynckeyshare) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare)
+}
+inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::release_appstatesynckeyshare() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_;
+  _impl_.appstatesynckeyshare_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyshare() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyShare)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_;
+  _impl_.appstatesynckeyshare_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::_internal_mutable_appstatesynckeyshare() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.appstatesynckeyshare_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(GetArenaForAllocation());
+    _impl_.appstatesynckeyshare_ = p;
+  }
+  return _impl_.appstatesynckeyshare_;
+}
+inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::mutable_appstatesynckeyshare() {
+  ::proto::Message_AppStateSyncKeyShare* _msg = _internal_mutable_appstatesynckeyshare();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyShare)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.appstatesynckeyshare_;
+  }
+  if (appstatesynckeyshare) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyshare);
+    if (message_arena != submessage_arena) {
+      appstatesynckeyshare = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, appstatesynckeyshare, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.appstatesynckeyshare_ = appstatesynckeyshare;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare)
+}
+
+// optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyrequest() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyrequest_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_appstatesynckeyrequest() const {
+  return _internal_has_appstatesynckeyrequest();
+}
+inline void Message_ProtocolMessage::clear_appstatesynckeyrequest() {
+  if (_impl_.appstatesynckeyrequest_ != nullptr) _impl_.appstatesynckeyrequest_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::_internal_appstatesynckeyrequest() const {
+  const ::proto::Message_AppStateSyncKeyRequest* p = _impl_.appstatesynckeyrequest_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyRequest&>(
+      ::proto::_Message_AppStateSyncKeyRequest_default_instance_);
+}
+inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::appstatesynckeyrequest() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
+  return _internal_appstatesynckeyrequest();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyrequest(
+    ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyrequest_);
+  }
+  _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest;
+  if (appstatesynckeyrequest) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
+}
+inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::release_appstatesynckeyrequest() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_;
+  _impl_.appstatesynckeyrequest_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyrequest() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_;
+  _impl_.appstatesynckeyrequest_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::_internal_mutable_appstatesynckeyrequest() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.appstatesynckeyrequest_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(GetArenaForAllocation());
+    _impl_.appstatesynckeyrequest_ = p;
+  }
+  return _impl_.appstatesynckeyrequest_;
+}
+inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::mutable_appstatesynckeyrequest() {
+  ::proto::Message_AppStateSyncKeyRequest* _msg = _internal_mutable_appstatesynckeyrequest();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.appstatesynckeyrequest_;
+  }
+  if (appstatesynckeyrequest) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyrequest);
+    if (message_arena != submessage_arena) {
+      appstatesynckeyrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, appstatesynckeyrequest, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
+}
+
+// optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+inline bool Message_ProtocolMessage::_internal_has_initialsecuritynotificationsettingsync() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.initialsecuritynotificationsettingsync_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_initialsecuritynotificationsettingsync() const {
+  return _internal_has_initialsecuritynotificationsettingsync();
+}
+inline void Message_ProtocolMessage::clear_initialsecuritynotificationsettingsync() {
+  if (_impl_.initialsecuritynotificationsettingsync_ != nullptr) _impl_.initialsecuritynotificationsettingsync_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::_internal_initialsecuritynotificationsettingsync() const {
+  const ::proto::Message_InitialSecurityNotificationSettingSync* p = _impl_.initialsecuritynotificationsettingsync_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InitialSecurityNotificationSettingSync&>(
+      ::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_);
+}
+inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::initialsecuritynotificationsettingsync() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
+  return _internal_initialsecuritynotificationsettingsync();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_initialsecuritynotificationsettingsync(
+    ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initialsecuritynotificationsettingsync_);
+  }
+  _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync;
+  if (initialsecuritynotificationsettingsync) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
+}
+inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::release_initialsecuritynotificationsettingsync() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_;
+  _impl_.initialsecuritynotificationsettingsync_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::unsafe_arena_release_initialsecuritynotificationsettingsync() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_;
+  _impl_.initialsecuritynotificationsettingsync_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::_internal_mutable_initialsecuritynotificationsettingsync() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.initialsecuritynotificationsettingsync_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(GetArenaForAllocation());
+    _impl_.initialsecuritynotificationsettingsync_ = p;
+  }
+  return _impl_.initialsecuritynotificationsettingsync_;
+}
+inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::mutable_initialsecuritynotificationsettingsync() {
+  ::proto::Message_InitialSecurityNotificationSettingSync* _msg = _internal_mutable_initialsecuritynotificationsettingsync();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.initialsecuritynotificationsettingsync_;
+  }
+  if (initialsecuritynotificationsettingsync) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initialsecuritynotificationsettingsync);
+    if (message_arena != submessage_arena) {
+      initialsecuritynotificationsettingsync = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, initialsecuritynotificationsettingsync, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
+}
+
+// optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+inline bool Message_ProtocolMessage::_internal_has_appstatefatalexceptionnotification() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.appstatefatalexceptionnotification_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_appstatefatalexceptionnotification() const {
+  return _internal_has_appstatefatalexceptionnotification();
+}
+inline void Message_ProtocolMessage::clear_appstatefatalexceptionnotification() {
+  if (_impl_.appstatefatalexceptionnotification_ != nullptr) _impl_.appstatefatalexceptionnotification_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::_internal_appstatefatalexceptionnotification() const {
+  const ::proto::Message_AppStateFatalExceptionNotification* p = _impl_.appstatefatalexceptionnotification_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateFatalExceptionNotification&>(
+      ::proto::_Message_AppStateFatalExceptionNotification_default_instance_);
+}
+inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::appstatefatalexceptionnotification() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
+  return _internal_appstatefatalexceptionnotification();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatefatalexceptionnotification(
+    ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatefatalexceptionnotification_);
+  }
+  _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification;
+  if (appstatefatalexceptionnotification) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
+}
+inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::release_appstatefatalexceptionnotification() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_;
+  _impl_.appstatefatalexceptionnotification_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::unsafe_arena_release_appstatefatalexceptionnotification() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_;
+  _impl_.appstatefatalexceptionnotification_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::_internal_mutable_appstatefatalexceptionnotification() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.appstatefatalexceptionnotification_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(GetArenaForAllocation());
+    _impl_.appstatefatalexceptionnotification_ = p;
+  }
+  return _impl_.appstatefatalexceptionnotification_;
+}
+inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::mutable_appstatefatalexceptionnotification() {
+  ::proto::Message_AppStateFatalExceptionNotification* _msg = _internal_mutable_appstatefatalexceptionnotification();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.appstatefatalexceptionnotification_;
+  }
+  if (appstatefatalexceptionnotification) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatefatalexceptionnotification);
+    if (message_arena != submessage_arena) {
+      appstatefatalexceptionnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, appstatefatalexceptionnotification, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
+}
+
+// optional .proto.DisappearingMode disappearingMode = 11;
+inline bool Message_ProtocolMessage::_internal_has_disappearingmode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_disappearingmode() const {
+  return _internal_has_disappearingmode();
+}
+inline void Message_ProtocolMessage::clear_disappearingmode() {
+  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::DisappearingMode& Message_ProtocolMessage::_internal_disappearingmode() const {
+  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
+      ::proto::_DisappearingMode_default_instance_);
+}
+inline const ::proto::DisappearingMode& Message_ProtocolMessage::disappearingmode() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.disappearingMode)
+  return _internal_disappearingmode();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_disappearingmode(
+    ::proto::DisappearingMode* disappearingmode) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  if (disappearingmode) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.disappearingMode)
+}
+inline ::proto::DisappearingMode* Message_ProtocolMessage::release_disappearingmode() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::DisappearingMode* Message_ProtocolMessage::unsafe_arena_release_disappearingmode() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.disappearingMode)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
+  _impl_.disappearingmode_ = nullptr;
+  return temp;
+}
+inline ::proto::DisappearingMode* Message_ProtocolMessage::_internal_mutable_disappearingmode() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.disappearingmode_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
+    _impl_.disappearingmode_ = p;
+  }
+  return _impl_.disappearingmode_;
+}
+inline ::proto::DisappearingMode* Message_ProtocolMessage::mutable_disappearingmode() {
+  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.disappearingMode)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.disappearingmode_;
+  }
+  if (disappearingmode) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
+    if (message_arena != submessage_arena) {
+      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, disappearingmode, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.disappearingmode_ = disappearingmode;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.disappearingMode)
+}
+
+// optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+inline bool Message_ProtocolMessage::_internal_has_requestmediauploadmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestmediauploadmessage_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_requestmediauploadmessage() const {
+  return _internal_has_requestmediauploadmessage();
+}
+inline void Message_ProtocolMessage::clear_requestmediauploadmessage() {
+  if (_impl_.requestmediauploadmessage_ != nullptr) _impl_.requestmediauploadmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::_internal_requestmediauploadmessage() const {
+  const ::proto::Message_RequestMediaUploadMessage* p = _impl_.requestmediauploadmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestMediaUploadMessage&>(
+      ::proto::_Message_RequestMediaUploadMessage_default_instance_);
+}
+inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::requestmediauploadmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadMessage)
+  return _internal_requestmediauploadmessage();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadmessage(
+    ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadmessage_);
+  }
+  _impl_.requestmediauploadmessage_ = requestmediauploadmessage;
+  if (requestmediauploadmessage) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage)
+}
+inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::release_requestmediauploadmessage() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_;
+  _impl_.requestmediauploadmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadMessage)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_;
+  _impl_.requestmediauploadmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadmessage() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.requestmediauploadmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(GetArenaForAllocation());
+    _impl_.requestmediauploadmessage_ = p;
+  }
+  return _impl_.requestmediauploadmessage_;
+}
+inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::mutable_requestmediauploadmessage() {
+  ::proto::Message_RequestMediaUploadMessage* _msg = _internal_mutable_requestmediauploadmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadMessage)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestmediauploadmessage_;
+  }
+  if (requestmediauploadmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadmessage);
+    if (message_arena != submessage_arena) {
+      requestmediauploadmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestmediauploadmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.requestmediauploadmessage_ = requestmediauploadmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage)
+}
+
+// optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+inline bool Message_ProtocolMessage::_internal_has_requestmediauploadresponsemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestmediauploadresponsemessage_ != nullptr);
+  return value;
+}
+inline bool Message_ProtocolMessage::has_requestmediauploadresponsemessage() const {
+  return _internal_has_requestmediauploadresponsemessage();
+}
+inline void Message_ProtocolMessage::clear_requestmediauploadresponsemessage() {
+  if (_impl_.requestmediauploadresponsemessage_ != nullptr) _impl_.requestmediauploadresponsemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::_internal_requestmediauploadresponsemessage() const {
+  const ::proto::Message_RequestMediaUploadResponseMessage* p = _impl_.requestmediauploadresponsemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestMediaUploadResponseMessage&>(
+      ::proto::_Message_RequestMediaUploadResponseMessage_default_instance_);
+}
+inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::requestmediauploadresponsemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
+  return _internal_requestmediauploadresponsemessage();
+}
+inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadresponsemessage(
+    ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadresponsemessage_);
+  }
+  _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage;
+  if (requestmediauploadresponsemessage) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::release_requestmediauploadresponsemessage() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_;
+  _impl_.requestmediauploadresponsemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadresponsemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_;
+  _impl_.requestmediauploadresponsemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadresponsemessage() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.requestmediauploadresponsemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(GetArenaForAllocation());
+    _impl_.requestmediauploadresponsemessage_ = p;
+  }
+  return _impl_.requestmediauploadresponsemessage_;
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::mutable_requestmediauploadresponsemessage() {
+  ::proto::Message_RequestMediaUploadResponseMessage* _msg = _internal_mutable_requestmediauploadresponsemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
+  return _msg;
+}
+inline void Message_ProtocolMessage::set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestmediauploadresponsemessage_;
+  }
+  if (requestmediauploadresponsemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadresponsemessage);
+    if (message_arena != submessage_arena) {
+      requestmediauploadresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestmediauploadresponsemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
+}
+
+// -------------------------------------------------------------------
+
+// Message_ReactionMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool Message_ReactionMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Message_ReactionMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void Message_ReactionMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::MessageKey& Message_ReactionMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_ReactionMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.key)
+  return _internal_key();
+}
+inline void Message_ReactionMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ReactionMessage.key)
+}
+inline ::proto::MessageKey* Message_ReactionMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_ReactionMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_ReactionMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Message_ReactionMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.key)
+  return _msg;
+}
+inline void Message_ReactionMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.key)
+}
+
+// optional string text = 2;
+inline bool Message_ReactionMessage::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_ReactionMessage::has_text() const {
+  return _internal_has_text();
+}
+inline void Message_ReactionMessage::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_ReactionMessage::text() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ReactionMessage::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.text)
+}
+inline std::string* Message_ReactionMessage::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.text)
+  return _s;
+}
+inline const std::string& Message_ReactionMessage::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Message_ReactionMessage::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ReactionMessage::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ReactionMessage::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ReactionMessage::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.text)
+}
+
+// optional string groupingKey = 3;
+inline bool Message_ReactionMessage::_internal_has_groupingkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_ReactionMessage::has_groupingkey() const {
+  return _internal_has_groupingkey();
+}
+inline void Message_ReactionMessage::clear_groupingkey() {
+  _impl_.groupingkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_ReactionMessage::groupingkey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.groupingKey)
+  return _internal_groupingkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_ReactionMessage::set_groupingkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.groupingkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.groupingKey)
+}
+inline std::string* Message_ReactionMessage::mutable_groupingkey() {
+  std::string* _s = _internal_mutable_groupingkey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.groupingKey)
+  return _s;
+}
+inline const std::string& Message_ReactionMessage::_internal_groupingkey() const {
+  return _impl_.groupingkey_.Get();
+}
+inline void Message_ReactionMessage::_internal_set_groupingkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.groupingkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_ReactionMessage::_internal_mutable_groupingkey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.groupingkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_ReactionMessage::release_groupingkey() {
+  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.groupingKey)
+  if (!_internal_has_groupingkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.groupingkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupingkey_.IsDefault()) {
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_ReactionMessage::set_allocated_groupingkey(std::string* groupingkey) {
+  if (groupingkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupingkey_.IsDefault()) {
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.groupingKey)
+}
+
+// optional int64 senderTimestampMs = 4;
+inline bool Message_ReactionMessage::_internal_has_sendertimestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_ReactionMessage::has_sendertimestampms() const {
+  return _internal_has_sendertimestampms();
+}
+inline void Message_ReactionMessage::clear_sendertimestampms() {
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t Message_ReactionMessage::_internal_sendertimestampms() const {
+  return _impl_.sendertimestampms_;
+}
+inline int64_t Message_ReactionMessage::sendertimestampms() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.senderTimestampMs)
+  return _internal_sendertimestampms();
+}
+inline void Message_ReactionMessage::_internal_set_sendertimestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.sendertimestampms_ = value;
+}
+inline void Message_ReactionMessage::set_sendertimestampms(int64_t value) {
+  _internal_set_sendertimestampms(value);
+  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.senderTimestampMs)
+}
+
+// -------------------------------------------------------------------
+
+// Message_RequestMediaUploadMessage
+
+// repeated string fileSha256 = 1;
+inline int Message_RequestMediaUploadMessage::_internal_filesha256_size() const {
+  return _impl_.filesha256_.size();
+}
+inline int Message_RequestMediaUploadMessage::filesha256_size() const {
+  return _internal_filesha256_size();
+}
+inline void Message_RequestMediaUploadMessage::clear_filesha256() {
+  _impl_.filesha256_.Clear();
+}
+inline std::string* Message_RequestMediaUploadMessage::add_filesha256() {
+  std::string* _s = _internal_add_filesha256();
+  // @@protoc_insertion_point(field_add_mutable:proto.Message.RequestMediaUploadMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_RequestMediaUploadMessage::_internal_filesha256(int index) const {
+  return _impl_.filesha256_.Get(index);
+}
+inline const std::string& Message_RequestMediaUploadMessage::filesha256(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.fileSha256)
+  return _internal_filesha256(index);
+}
+inline std::string* Message_RequestMediaUploadMessage::mutable_filesha256(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadMessage.fileSha256)
+  return _impl_.filesha256_.Mutable(index);
+}
+inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const std::string& value) {
+  _impl_.filesha256_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::set_filesha256(int index, std::string&& value) {
+  _impl_.filesha256_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.filesha256_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value, size_t size) {
+  _impl_.filesha256_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline std::string* Message_RequestMediaUploadMessage::_internal_add_filesha256() {
+  return _impl_.filesha256_.Add();
+}
+inline void Message_RequestMediaUploadMessage::add_filesha256(const std::string& value) {
+  _impl_.filesha256_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::add_filesha256(std::string&& value) {
+  _impl_.filesha256_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.filesha256_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value, size_t size) {
+  _impl_.filesha256_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.Message.RequestMediaUploadMessage.fileSha256)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Message_RequestMediaUploadMessage::filesha256() const {
+  // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadMessage.fileSha256)
+  return _impl_.filesha256_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Message_RequestMediaUploadMessage::mutable_filesha256() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadMessage.fileSha256)
+  return &_impl_.filesha256_;
+}
+
+// optional .proto.Message.RmrSource rmrSource = 2;
+inline bool Message_RequestMediaUploadMessage::_internal_has_rmrsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_RequestMediaUploadMessage::has_rmrsource() const {
+  return _internal_has_rmrsource();
+}
+inline void Message_RequestMediaUploadMessage::clear_rmrsource() {
+  _impl_.rmrsource_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::_internal_rmrsource() const {
+  return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_);
+}
+inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::rmrsource() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.rmrSource)
+  return _internal_rmrsource();
+}
+inline void Message_RequestMediaUploadMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) {
+  assert(::proto::Message_RmrSource_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.rmrsource_ = value;
+}
+inline void Message_RequestMediaUploadMessage::set_rmrsource(::proto::Message_RmrSource value) {
+  _internal_set_rmrsource(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.rmrSource)
+}
+
+// -------------------------------------------------------------------
+
+// Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult
+
+// optional string fileSha256 = 1;
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.filesha256_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
+}
+inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
+  return _s;
+}
+inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
+}
+
+// optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_mediauploadresult() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_mediauploadresult() const {
+  return _internal_has_mediauploadresult();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_mediauploadresult() {
+  _impl_.mediauploadresult_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mediauploadresult() const {
+  return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.mediauploadresult_);
+}
+inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mediauploadresult() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult)
+  return _internal_mediauploadresult();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) {
+  assert(::proto::MediaRetryNotification_ResultType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.mediauploadresult_ = value;
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) {
+  _internal_set_mediauploadresult(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult)
+}
+
+// optional .proto.Message.StickerMessage stickerMessage = 3;
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_stickermessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr);
+  return value;
+}
+inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_stickermessage() const {
+  return _internal_has_stickermessage();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_stickermessage() {
+  if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_stickermessage() const {
+  const ::proto::Message_StickerMessage* p = _impl_.stickermessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerMessage&>(
+      ::proto::_Message_StickerMessage_default_instance_);
+}
+inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::stickermessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
+  return _internal_stickermessage();
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_set_allocated_stickermessage(
+    ::proto::Message_StickerMessage* stickermessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_);
+  }
+  _impl_.stickermessage_ = stickermessage;
+  if (stickermessage) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
+}
+inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_stickermessage() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
+  _impl_.stickermessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_release_stickermessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
+  _impl_.stickermessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_stickermessage() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.stickermessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation());
+    _impl_.stickermessage_ = p;
+  }
+  return _impl_.stickermessage_;
+}
+inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_stickermessage() {
+  ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
+  return _msg;
+}
+inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.stickermessage_;
+  }
+  if (stickermessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage);
+    if (message_arena != submessage_arena) {
+      stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, stickermessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.stickermessage_ = stickermessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
+}
+
+// -------------------------------------------------------------------
+
+// Message_RequestMediaUploadResponseMessage
+
+// optional .proto.Message.RmrSource rmrSource = 1;
+inline bool Message_RequestMediaUploadResponseMessage::_internal_has_rmrsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_RequestMediaUploadResponseMessage::has_rmrsource() const {
+  return _internal_has_rmrsource();
+}
+inline void Message_RequestMediaUploadResponseMessage::clear_rmrsource() {
+  _impl_.rmrsource_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::_internal_rmrsource() const {
+  return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_);
+}
+inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::rmrsource() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.rmrSource)
+  return _internal_rmrsource();
+}
+inline void Message_RequestMediaUploadResponseMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) {
+  assert(::proto::Message_RmrSource_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.rmrsource_ = value;
+}
+inline void Message_RequestMediaUploadResponseMessage::set_rmrsource(::proto::Message_RmrSource value) {
+  _internal_set_rmrsource(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.rmrSource)
+}
+
+// optional string stanzaId = 2;
+inline bool Message_RequestMediaUploadResponseMessage::_internal_has_stanzaid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_RequestMediaUploadResponseMessage::has_stanzaid() const {
+  return _internal_has_stanzaid();
+}
+inline void Message_RequestMediaUploadResponseMessage::clear_stanzaid() {
+  _impl_.stanzaid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_RequestMediaUploadResponseMessage::stanzaid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
+  return _internal_stanzaid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_RequestMediaUploadResponseMessage::set_stanzaid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
+}
+inline std::string* Message_RequestMediaUploadResponseMessage::mutable_stanzaid() {
+  std::string* _s = _internal_mutable_stanzaid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
+  return _s;
+}
+inline const std::string& Message_RequestMediaUploadResponseMessage::_internal_stanzaid() const {
+  return _impl_.stanzaid_.Get();
+}
+inline void Message_RequestMediaUploadResponseMessage::_internal_set_stanzaid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_RequestMediaUploadResponseMessage::_internal_mutable_stanzaid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_RequestMediaUploadResponseMessage::release_stanzaid() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
+  if (!_internal_has_stanzaid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.stanzaid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_RequestMediaUploadResponseMessage::set_allocated_stanzaid(std::string* stanzaid) {
+  if (stanzaid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
+}
+
+// repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
+inline int Message_RequestMediaUploadResponseMessage::_internal_reuploadresult_size() const {
+  return _impl_.reuploadresult_.size();
+}
+inline int Message_RequestMediaUploadResponseMessage::reuploadresult_size() const {
+  return _internal_reuploadresult_size();
+}
+inline void Message_RequestMediaUploadResponseMessage::clear_reuploadresult() {
+  _impl_.reuploadresult_.Clear();
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::mutable_reuploadresult(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
+  return _impl_.reuploadresult_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >*
+Message_RequestMediaUploadResponseMessage::mutable_reuploadresult() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
+  return &_impl_.reuploadresult_;
+}
+inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::_internal_reuploadresult(int index) const {
+  return _impl_.reuploadresult_.Get(index);
+}
+inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::reuploadresult(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
+  return _internal_reuploadresult(index);
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::_internal_add_reuploadresult() {
+  return _impl_.reuploadresult_.Add();
+}
+inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::add_reuploadresult() {
+  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _add = _internal_add_reuploadresult();
+  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >&
+Message_RequestMediaUploadResponseMessage::reuploadresult() const {
+  // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
+  return _impl_.reuploadresult_;
+}
+
+// -------------------------------------------------------------------
+
+// Message_RequestPaymentMessage
+
+// optional .proto.Message noteMessage = 4;
+inline bool Message_RequestPaymentMessage::_internal_has_notemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr);
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_notemessage() const {
+  return _internal_has_notemessage();
+}
+inline void Message_RequestPaymentMessage::clear_notemessage() {
+  if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message& Message_RequestPaymentMessage::_internal_notemessage() const {
+  const ::proto::Message* p = _impl_.notemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& Message_RequestPaymentMessage::notemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.noteMessage)
+  return _internal_notemessage();
+}
+inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_notemessage(
+    ::proto::Message* notemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_);
+  }
+  _impl_.notemessage_ = notemessage;
+  if (notemessage) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.noteMessage)
+}
+inline ::proto::Message* Message_RequestPaymentMessage::release_notemessage() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.notemessage_;
+  _impl_.notemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* Message_RequestPaymentMessage::unsafe_arena_release_notemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.noteMessage)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.notemessage_;
+  _impl_.notemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* Message_RequestPaymentMessage::_internal_mutable_notemessage() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.notemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.notemessage_ = p;
+  }
+  return _impl_.notemessage_;
+}
+inline ::proto::Message* Message_RequestPaymentMessage::mutable_notemessage() {
+  ::proto::Message* _msg = _internal_mutable_notemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.noteMessage)
+  return _msg;
+}
+inline void Message_RequestPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.notemessage_;
+  }
+  if (notemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage);
+    if (message_arena != submessage_arena) {
+      notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, notemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.notemessage_ = notemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.noteMessage)
+}
+
+// optional string currencyCodeIso4217 = 1;
+inline bool Message_RequestPaymentMessage::_internal_has_currencycodeiso4217() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_currencycodeiso4217() const {
+  return _internal_has_currencycodeiso4217();
+}
+inline void Message_RequestPaymentMessage::clear_currencycodeiso4217() {
+  _impl_.currencycodeiso4217_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_RequestPaymentMessage::currencycodeiso4217() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
+  return _internal_currencycodeiso4217();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_RequestPaymentMessage::set_currencycodeiso4217(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.currencycodeiso4217_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
+}
+inline std::string* Message_RequestPaymentMessage::mutable_currencycodeiso4217() {
+  std::string* _s = _internal_mutable_currencycodeiso4217();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
+  return _s;
+}
+inline const std::string& Message_RequestPaymentMessage::_internal_currencycodeiso4217() const {
+  return _impl_.currencycodeiso4217_.Get();
+}
+inline void Message_RequestPaymentMessage::_internal_set_currencycodeiso4217(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.currencycodeiso4217_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_RequestPaymentMessage::_internal_mutable_currencycodeiso4217() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.currencycodeiso4217_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_RequestPaymentMessage::release_currencycodeiso4217() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
+  if (!_internal_has_currencycodeiso4217()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.currencycodeiso4217_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycodeiso4217_.IsDefault()) {
+    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_RequestPaymentMessage::set_allocated_currencycodeiso4217(std::string* currencycodeiso4217) {
+  if (currencycodeiso4217 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.currencycodeiso4217_.SetAllocated(currencycodeiso4217, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycodeiso4217_.IsDefault()) {
+    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
+}
+
+// optional uint64 amount1000 = 2;
+inline bool Message_RequestPaymentMessage::_internal_has_amount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_amount1000() const {
+  return _internal_has_amount1000();
+}
+inline void Message_RequestPaymentMessage::clear_amount1000() {
+  _impl_.amount1000_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint64_t Message_RequestPaymentMessage::_internal_amount1000() const {
+  return _impl_.amount1000_;
+}
+inline uint64_t Message_RequestPaymentMessage::amount1000() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount1000)
+  return _internal_amount1000();
+}
+inline void Message_RequestPaymentMessage::_internal_set_amount1000(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.amount1000_ = value;
+}
+inline void Message_RequestPaymentMessage::set_amount1000(uint64_t value) {
+  _internal_set_amount1000(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.amount1000)
+}
+
+// optional string requestFrom = 3;
+inline bool Message_RequestPaymentMessage::_internal_has_requestfrom() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_requestfrom() const {
+  return _internal_has_requestfrom();
+}
+inline void Message_RequestPaymentMessage::clear_requestfrom() {
+  _impl_.requestfrom_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_RequestPaymentMessage::requestfrom() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.requestFrom)
+  return _internal_requestfrom();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_RequestPaymentMessage::set_requestfrom(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.requestfrom_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.requestFrom)
+}
+inline std::string* Message_RequestPaymentMessage::mutable_requestfrom() {
+  std::string* _s = _internal_mutable_requestfrom();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.requestFrom)
+  return _s;
+}
+inline const std::string& Message_RequestPaymentMessage::_internal_requestfrom() const {
+  return _impl_.requestfrom_.Get();
+}
+inline void Message_RequestPaymentMessage::_internal_set_requestfrom(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.requestfrom_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_RequestPaymentMessage::_internal_mutable_requestfrom() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.requestfrom_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_RequestPaymentMessage::release_requestfrom() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.requestFrom)
+  if (!_internal_has_requestfrom()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.requestfrom_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.requestfrom_.IsDefault()) {
+    _impl_.requestfrom_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_RequestPaymentMessage::set_allocated_requestfrom(std::string* requestfrom) {
+  if (requestfrom != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.requestfrom_.SetAllocated(requestfrom, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.requestfrom_.IsDefault()) {
+    _impl_.requestfrom_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.requestFrom)
+}
+
+// optional int64 expiryTimestamp = 5;
+inline bool Message_RequestPaymentMessage::_internal_has_expirytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_expirytimestamp() const {
+  return _internal_has_expirytimestamp();
+}
+inline void Message_RequestPaymentMessage::clear_expirytimestamp() {
+  _impl_.expirytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline int64_t Message_RequestPaymentMessage::_internal_expirytimestamp() const {
+  return _impl_.expirytimestamp_;
+}
+inline int64_t Message_RequestPaymentMessage::expirytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.expiryTimestamp)
+  return _internal_expirytimestamp();
+}
+inline void Message_RequestPaymentMessage::_internal_set_expirytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.expirytimestamp_ = value;
+}
+inline void Message_RequestPaymentMessage::set_expirytimestamp(int64_t value) {
+  _internal_set_expirytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.expiryTimestamp)
+}
+
+// optional .proto.Money amount = 6;
+inline bool Message_RequestPaymentMessage::_internal_has_amount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.amount_ != nullptr);
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_amount() const {
+  return _internal_has_amount();
+}
+inline void Message_RequestPaymentMessage::clear_amount() {
+  if (_impl_.amount_ != nullptr) _impl_.amount_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::Money& Message_RequestPaymentMessage::_internal_amount() const {
+  const ::proto::Money* p = _impl_.amount_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
+      ::proto::_Money_default_instance_);
+}
+inline const ::proto::Money& Message_RequestPaymentMessage::amount() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount)
+  return _internal_amount();
+}
+inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_amount(
+    ::proto::Money* amount) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.amount_);
+  }
+  _impl_.amount_ = amount;
+  if (amount) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.amount)
+}
+inline ::proto::Money* Message_RequestPaymentMessage::release_amount() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Money* temp = _impl_.amount_;
+  _impl_.amount_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Money* Message_RequestPaymentMessage::unsafe_arena_release_amount() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.amount)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Money* temp = _impl_.amount_;
+  _impl_.amount_ = nullptr;
+  return temp;
+}
+inline ::proto::Money* Message_RequestPaymentMessage::_internal_mutable_amount() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.amount_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
+    _impl_.amount_ = p;
+  }
+  return _impl_.amount_;
+}
+inline ::proto::Money* Message_RequestPaymentMessage::mutable_amount() {
+  ::proto::Money* _msg = _internal_mutable_amount();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.amount)
+  return _msg;
+}
+inline void Message_RequestPaymentMessage::set_allocated_amount(::proto::Money* amount) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.amount_;
+  }
+  if (amount) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(amount);
+    if (message_arena != submessage_arena) {
+      amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, amount, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.amount_ = amount;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.amount)
+}
+
+// optional .proto.PaymentBackground background = 7;
+inline bool Message_RequestPaymentMessage::_internal_has_background() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr);
+  return value;
+}
+inline bool Message_RequestPaymentMessage::has_background() const {
+  return _internal_has_background();
+}
+inline void Message_RequestPaymentMessage::clear_background() {
+  if (_impl_.background_ != nullptr) _impl_.background_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::_internal_background() const {
+  const ::proto::PaymentBackground* p = _impl_.background_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground&>(
+      ::proto::_PaymentBackground_default_instance_);
+}
+inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::background() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.background)
+  return _internal_background();
+}
+inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_background(
+    ::proto::PaymentBackground* background) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_);
+  }
+  _impl_.background_ = background;
+  if (background) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.background)
+}
+inline ::proto::PaymentBackground* Message_RequestPaymentMessage::release_background() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::PaymentBackground* temp = _impl_.background_;
+  _impl_.background_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PaymentBackground* Message_RequestPaymentMessage::unsafe_arena_release_background() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.background)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::PaymentBackground* temp = _impl_.background_;
+  _impl_.background_ = nullptr;
+  return temp;
+}
+inline ::proto::PaymentBackground* Message_RequestPaymentMessage::_internal_mutable_background() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.background_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation());
+    _impl_.background_ = p;
+  }
+  return _impl_.background_;
+}
+inline ::proto::PaymentBackground* Message_RequestPaymentMessage::mutable_background() {
+  ::proto::PaymentBackground* _msg = _internal_mutable_background();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.background)
+  return _msg;
+}
+inline void Message_RequestPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.background_;
+  }
+  if (background) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background);
+    if (message_arena != submessage_arena) {
+      background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, background, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.background_ = background;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.background)
+}
+
+// -------------------------------------------------------------------
+
+// Message_RequestPhoneNumberMessage
+
+// optional .proto.ContextInfo contextInfo = 1;
+inline bool Message_RequestPhoneNumberMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_RequestPhoneNumberMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_RequestPhoneNumberMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.RequestPhoneNumberMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_RequestPhoneNumberMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.RequestPhoneNumberMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPhoneNumberMessage.contextInfo)
+  return _msg;
+}
+inline void Message_RequestPhoneNumberMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_SendPaymentMessage
+
+// optional .proto.Message noteMessage = 2;
+inline bool Message_SendPaymentMessage::_internal_has_notemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr);
+  return value;
+}
+inline bool Message_SendPaymentMessage::has_notemessage() const {
+  return _internal_has_notemessage();
+}
+inline void Message_SendPaymentMessage::clear_notemessage() {
+  if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message& Message_SendPaymentMessage::_internal_notemessage() const {
+  const ::proto::Message* p = _impl_.notemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& Message_SendPaymentMessage::notemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.noteMessage)
+  return _internal_notemessage();
+}
+inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_notemessage(
+    ::proto::Message* notemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_);
+  }
+  _impl_.notemessage_ = notemessage;
+  if (notemessage) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.noteMessage)
+}
+inline ::proto::Message* Message_SendPaymentMessage::release_notemessage() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message* temp = _impl_.notemessage_;
+  _impl_.notemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* Message_SendPaymentMessage::unsafe_arena_release_notemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.noteMessage)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message* temp = _impl_.notemessage_;
+  _impl_.notemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* Message_SendPaymentMessage::_internal_mutable_notemessage() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.notemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.notemessage_ = p;
+  }
+  return _impl_.notemessage_;
+}
+inline ::proto::Message* Message_SendPaymentMessage::mutable_notemessage() {
+  ::proto::Message* _msg = _internal_mutable_notemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.noteMessage)
+  return _msg;
+}
+inline void Message_SendPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.notemessage_;
+  }
+  if (notemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage);
+    if (message_arena != submessage_arena) {
+      notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, notemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.notemessage_ = notemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.noteMessage)
+}
+
+// optional .proto.MessageKey requestMessageKey = 3;
+inline bool Message_SendPaymentMessage::_internal_has_requestmessagekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr);
+  return value;
+}
+inline bool Message_SendPaymentMessage::has_requestmessagekey() const {
+  return _internal_has_requestmessagekey();
+}
+inline void Message_SendPaymentMessage::clear_requestmessagekey() {
+  if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::MessageKey& Message_SendPaymentMessage::_internal_requestmessagekey() const {
+  const ::proto::MessageKey* p = _impl_.requestmessagekey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Message_SendPaymentMessage::requestmessagekey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.requestMessageKey)
+  return _internal_requestmessagekey();
+}
+inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_requestmessagekey(
+    ::proto::MessageKey* requestmessagekey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_);
+  }
+  _impl_.requestmessagekey_ = requestmessagekey;
+  if (requestmessagekey) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey)
+}
+inline ::proto::MessageKey* Message_SendPaymentMessage::release_requestmessagekey() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
+  _impl_.requestmessagekey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Message_SendPaymentMessage::unsafe_arena_release_requestmessagekey() {
+  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.requestMessageKey)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
+  _impl_.requestmessagekey_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Message_SendPaymentMessage::_internal_mutable_requestmessagekey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.requestmessagekey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.requestmessagekey_ = p;
+  }
+  return _impl_.requestmessagekey_;
+}
+inline ::proto::MessageKey* Message_SendPaymentMessage::mutable_requestmessagekey() {
+  ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.requestMessageKey)
+  return _msg;
+}
+inline void Message_SendPaymentMessage::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestmessagekey_;
+  }
+  if (requestmessagekey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey);
+    if (message_arena != submessage_arena) {
+      requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestmessagekey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.requestmessagekey_ = requestmessagekey;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey)
+}
+
+// optional .proto.PaymentBackground background = 4;
+inline bool Message_SendPaymentMessage::_internal_has_background() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr);
+  return value;
+}
+inline bool Message_SendPaymentMessage::has_background() const {
+  return _internal_has_background();
+}
+inline void Message_SendPaymentMessage::clear_background() {
+  if (_impl_.background_ != nullptr) _impl_.background_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::PaymentBackground& Message_SendPaymentMessage::_internal_background() const {
+  const ::proto::PaymentBackground* p = _impl_.background_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground&>(
+      ::proto::_PaymentBackground_default_instance_);
+}
+inline const ::proto::PaymentBackground& Message_SendPaymentMessage::background() const {
+  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.background)
+  return _internal_background();
+}
+inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_background(
+    ::proto::PaymentBackground* background) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_);
+  }
+  _impl_.background_ = background;
+  if (background) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.background)
+}
+inline ::proto::PaymentBackground* Message_SendPaymentMessage::release_background() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::PaymentBackground* temp = _impl_.background_;
+  _impl_.background_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PaymentBackground* Message_SendPaymentMessage::unsafe_arena_release_background() {
+  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.background)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::PaymentBackground* temp = _impl_.background_;
+  _impl_.background_ = nullptr;
+  return temp;
+}
+inline ::proto::PaymentBackground* Message_SendPaymentMessage::_internal_mutable_background() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.background_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation());
+    _impl_.background_ = p;
+  }
+  return _impl_.background_;
+}
+inline ::proto::PaymentBackground* Message_SendPaymentMessage::mutable_background() {
+  ::proto::PaymentBackground* _msg = _internal_mutable_background();
+  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.background)
+  return _msg;
+}
+inline void Message_SendPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.background_;
+  }
+  if (background) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background);
+    if (message_arena != submessage_arena) {
+      background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, background, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.background_ = background;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.background)
+}
+
+// -------------------------------------------------------------------
+
+// Message_SenderKeyDistributionMessage
+
+// optional string groupId = 1;
+inline bool Message_SenderKeyDistributionMessage::_internal_has_groupid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_SenderKeyDistributionMessage::has_groupid() const {
+  return _internal_has_groupid();
+}
+inline void Message_SenderKeyDistributionMessage::clear_groupid() {
+  _impl_.groupid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_SenderKeyDistributionMessage::groupid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.groupId)
+  return _internal_groupid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_SenderKeyDistributionMessage::set_groupid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.groupid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.groupId)
+}
+inline std::string* Message_SenderKeyDistributionMessage::mutable_groupid() {
+  std::string* _s = _internal_mutable_groupid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.groupId)
+  return _s;
+}
+inline const std::string& Message_SenderKeyDistributionMessage::_internal_groupid() const {
+  return _impl_.groupid_.Get();
+}
+inline void Message_SenderKeyDistributionMessage::_internal_set_groupid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.groupid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_groupid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.groupid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_SenderKeyDistributionMessage::release_groupid() {
+  // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.groupId)
+  if (!_internal_has_groupid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.groupid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupid_.IsDefault()) {
+    _impl_.groupid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_SenderKeyDistributionMessage::set_allocated_groupid(std::string* groupid) {
+  if (groupid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.groupid_.SetAllocated(groupid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupid_.IsDefault()) {
+    _impl_.groupid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.groupId)
+}
+
+// optional bytes axolotlSenderKeyDistributionMessage = 2;
+inline bool Message_SenderKeyDistributionMessage::_internal_has_axolotlsenderkeydistributionmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_SenderKeyDistributionMessage::has_axolotlsenderkeydistributionmessage() const {
+  return _internal_has_axolotlsenderkeydistributionmessage();
+}
+inline void Message_SenderKeyDistributionMessage::clear_axolotlsenderkeydistributionmessage() {
+  _impl_.axolotlsenderkeydistributionmessage_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_SenderKeyDistributionMessage::axolotlsenderkeydistributionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
+  return _internal_axolotlsenderkeydistributionmessage();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_SenderKeyDistributionMessage::set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.axolotlsenderkeydistributionmessage_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
+}
+inline std::string* Message_SenderKeyDistributionMessage::mutable_axolotlsenderkeydistributionmessage() {
+  std::string* _s = _internal_mutable_axolotlsenderkeydistributionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
+  return _s;
+}
+inline const std::string& Message_SenderKeyDistributionMessage::_internal_axolotlsenderkeydistributionmessage() const {
+  return _impl_.axolotlsenderkeydistributionmessage_.Get();
+}
+inline void Message_SenderKeyDistributionMessage::_internal_set_axolotlsenderkeydistributionmessage(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.axolotlsenderkeydistributionmessage_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_axolotlsenderkeydistributionmessage() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.axolotlsenderkeydistributionmessage_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_SenderKeyDistributionMessage::release_axolotlsenderkeydistributionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
+  if (!_internal_has_axolotlsenderkeydistributionmessage()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.axolotlsenderkeydistributionmessage_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) {
+    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_SenderKeyDistributionMessage::set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage) {
+  if (axolotlsenderkeydistributionmessage != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.axolotlsenderkeydistributionmessage_.SetAllocated(axolotlsenderkeydistributionmessage, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) {
+    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
+}
+
+// -------------------------------------------------------------------
+
+// Message_StickerMessage
+
+// optional string url = 1;
+inline bool Message_StickerMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_StickerMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_StickerMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.url)
+}
+inline std::string* Message_StickerMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.url)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_StickerMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.url)
+}
+
+// optional bytes fileSha256 = 2;
+inline bool Message_StickerMessage::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_StickerMessage::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_StickerMessage::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileSha256)
+}
+inline std::string* Message_StickerMessage::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_StickerMessage::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileSha256)
+}
+
+// optional bytes fileEncSha256 = 3;
+inline bool Message_StickerMessage::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_StickerMessage::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_StickerMessage::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileEncSha256)
+}
+inline std::string* Message_StickerMessage::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_StickerMessage::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileEncSha256)
+}
+
+// optional bytes mediaKey = 4;
+inline bool Message_StickerMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_StickerMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_StickerMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKey)
+}
+inline std::string* Message_StickerMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_StickerMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mediaKey)
+}
+
+// optional string mimetype = 5;
+inline bool Message_StickerMessage::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void Message_StickerMessage::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_StickerMessage::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mimetype)
+}
+inline std::string* Message_StickerMessage::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mimetype)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void Message_StickerMessage::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mimetype)
+}
+
+// optional uint32 height = 6;
+inline bool Message_StickerMessage::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_height() const {
+  return _internal_has_height();
+}
+inline void Message_StickerMessage::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint32_t Message_StickerMessage::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t Message_StickerMessage::height() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.height)
+  return _internal_height();
+}
+inline void Message_StickerMessage::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.height_ = value;
+}
+inline void Message_StickerMessage::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.height)
+}
+
+// optional uint32 width = 7;
+inline bool Message_StickerMessage::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_width() const {
+  return _internal_has_width();
+}
+inline void Message_StickerMessage::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline uint32_t Message_StickerMessage::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t Message_StickerMessage::width() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.width)
+  return _internal_width();
+}
+inline void Message_StickerMessage::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.width_ = value;
+}
+inline void Message_StickerMessage::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.width)
+}
+
+// optional string directPath = 8;
+inline bool Message_StickerMessage::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_StickerMessage::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_StickerMessage::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.directPath)
+}
+inline std::string* Message_StickerMessage::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.directPath)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_StickerMessage::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.directPath)
+}
+
+// optional uint64 fileLength = 9;
+inline bool Message_StickerMessage::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_StickerMessage::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline uint64_t Message_StickerMessage::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_StickerMessage::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileLength)
+  return _internal_filelength();
+}
+inline void Message_StickerMessage::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.filelength_ = value;
+}
+inline void Message_StickerMessage::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileLength)
+}
+
+// optional int64 mediaKeyTimestamp = 10;
+inline bool Message_StickerMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_StickerMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline int64_t Message_StickerMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_StickerMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_StickerMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_StickerMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKeyTimestamp)
+}
+
+// optional uint32 firstFrameLength = 11;
+inline bool Message_StickerMessage::_internal_has_firstframelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_firstframelength() const {
+  return _internal_has_firstframelength();
+}
+inline void Message_StickerMessage::clear_firstframelength() {
+  _impl_.firstframelength_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline uint32_t Message_StickerMessage::_internal_firstframelength() const {
+  return _impl_.firstframelength_;
+}
+inline uint32_t Message_StickerMessage::firstframelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameLength)
+  return _internal_firstframelength();
+}
+inline void Message_StickerMessage::_internal_set_firstframelength(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.firstframelength_ = value;
+}
+inline void Message_StickerMessage::set_firstframelength(uint32_t value) {
+  _internal_set_firstframelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameLength)
+}
+
+// optional bytes firstFrameSidecar = 12;
+inline bool Message_StickerMessage::_internal_has_firstframesidecar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_firstframesidecar() const {
+  return _internal_has_firstframesidecar();
+}
+inline void Message_StickerMessage::clear_firstframesidecar() {
+  _impl_.firstframesidecar_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_StickerMessage::firstframesidecar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameSidecar)
+  return _internal_firstframesidecar();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_firstframesidecar(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.firstframesidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameSidecar)
+}
+inline std::string* Message_StickerMessage::mutable_firstframesidecar() {
+  std::string* _s = _internal_mutable_firstframesidecar();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.firstFrameSidecar)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_firstframesidecar() const {
+  return _impl_.firstframesidecar_.Get();
+}
+inline void Message_StickerMessage::_internal_set_firstframesidecar(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.firstframesidecar_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_firstframesidecar() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.firstframesidecar_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_firstframesidecar() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.firstFrameSidecar)
+  if (!_internal_has_firstframesidecar()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.firstframesidecar_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstframesidecar_.IsDefault()) {
+    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_firstframesidecar(std::string* firstframesidecar) {
+  if (firstframesidecar != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.firstframesidecar_.SetAllocated(firstframesidecar, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstframesidecar_.IsDefault()) {
+    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.firstFrameSidecar)
+}
+
+// optional bool isAnimated = 13;
+inline bool Message_StickerMessage::_internal_has_isanimated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_isanimated() const {
+  return _internal_has_isanimated();
+}
+inline void Message_StickerMessage::clear_isanimated() {
+  _impl_.isanimated_ = false;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline bool Message_StickerMessage::_internal_isanimated() const {
+  return _impl_.isanimated_;
+}
+inline bool Message_StickerMessage::isanimated() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.isAnimated)
+  return _internal_isanimated();
+}
+inline void Message_StickerMessage::_internal_set_isanimated(bool value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.isanimated_ = value;
+}
+inline void Message_StickerMessage::set_isanimated(bool value) {
+  _internal_set_isanimated(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.isAnimated)
+}
+
+// optional bytes pngThumbnail = 16;
+inline bool Message_StickerMessage::_internal_has_pngthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_StickerMessage::has_pngthumbnail() const {
+  return _internal_has_pngthumbnail();
+}
+inline void Message_StickerMessage::clear_pngthumbnail() {
+  _impl_.pngthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_StickerMessage::pngthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.pngThumbnail)
+  return _internal_pngthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerMessage::set_pngthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.pngthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.pngThumbnail)
+}
+inline std::string* Message_StickerMessage::mutable_pngthumbnail() {
+  std::string* _s = _internal_mutable_pngthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.pngThumbnail)
+  return _s;
+}
+inline const std::string& Message_StickerMessage::_internal_pngthumbnail() const {
+  return _impl_.pngthumbnail_.Get();
+}
+inline void Message_StickerMessage::_internal_set_pngthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.pngthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::_internal_mutable_pngthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.pngthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerMessage::release_pngthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.pngThumbnail)
+  if (!_internal_has_pngthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.pngthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pngthumbnail_.IsDefault()) {
+    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerMessage::set_allocated_pngthumbnail(std::string* pngthumbnail) {
+  if (pngthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.pngthumbnail_.SetAllocated(pngthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pngthumbnail_.IsDefault()) {
+    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.pngThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_StickerMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_StickerMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_StickerMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::ContextInfo& Message_StickerMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_StickerMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_StickerMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.StickerMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_StickerMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_StickerMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_StickerMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_StickerMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.contextInfo)
+  return _msg;
+}
+inline void Message_StickerMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.contextInfo)
+}
+
+// -------------------------------------------------------------------
+
+// Message_StickerSyncRMRMessage
+
+// repeated string filehash = 1;
+inline int Message_StickerSyncRMRMessage::_internal_filehash_size() const {
+  return _impl_.filehash_.size();
+}
+inline int Message_StickerSyncRMRMessage::filehash_size() const {
+  return _internal_filehash_size();
+}
+inline void Message_StickerSyncRMRMessage::clear_filehash() {
+  _impl_.filehash_.Clear();
+}
+inline std::string* Message_StickerSyncRMRMessage::add_filehash() {
+  std::string* _s = _internal_add_filehash();
+  // @@protoc_insertion_point(field_add_mutable:proto.Message.StickerSyncRMRMessage.filehash)
+  return _s;
+}
+inline const std::string& Message_StickerSyncRMRMessage::_internal_filehash(int index) const {
+  return _impl_.filehash_.Get(index);
+}
+inline const std::string& Message_StickerSyncRMRMessage::filehash(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.filehash)
+  return _internal_filehash(index);
+}
+inline std::string* Message_StickerSyncRMRMessage::mutable_filehash(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.filehash)
+  return _impl_.filehash_.Mutable(index);
+}
+inline void Message_StickerSyncRMRMessage::set_filehash(int index, const std::string& value) {
+  _impl_.filehash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::set_filehash(int index, std::string&& value) {
+  _impl_.filehash_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.filehash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value, size_t size) {
+  _impl_.filehash_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline std::string* Message_StickerSyncRMRMessage::_internal_add_filehash() {
+  return _impl_.filehash_.Add();
+}
+inline void Message_StickerSyncRMRMessage::add_filehash(const std::string& value) {
+  _impl_.filehash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::add_filehash(std::string&& value) {
+  _impl_.filehash_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::add_filehash(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.filehash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline void Message_StickerSyncRMRMessage::add_filehash(const char* value, size_t size) {
+  _impl_.filehash_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.Message.StickerSyncRMRMessage.filehash)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Message_StickerSyncRMRMessage::filehash() const {
+  // @@protoc_insertion_point(field_list:proto.Message.StickerSyncRMRMessage.filehash)
+  return _impl_.filehash_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Message_StickerSyncRMRMessage::mutable_filehash() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.StickerSyncRMRMessage.filehash)
+  return &_impl_.filehash_;
+}
+
+// optional string rmrSource = 2;
+inline bool Message_StickerSyncRMRMessage::_internal_has_rmrsource() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_StickerSyncRMRMessage::has_rmrsource() const {
+  return _internal_has_rmrsource();
+}
+inline void Message_StickerSyncRMRMessage::clear_rmrsource() {
+  _impl_.rmrsource_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_StickerSyncRMRMessage::rmrsource() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.rmrSource)
+  return _internal_rmrsource();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_StickerSyncRMRMessage::set_rmrsource(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.rmrsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.rmrSource)
+}
+inline std::string* Message_StickerSyncRMRMessage::mutable_rmrsource() {
+  std::string* _s = _internal_mutable_rmrsource();
+  // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.rmrSource)
+  return _s;
+}
+inline const std::string& Message_StickerSyncRMRMessage::_internal_rmrsource() const {
+  return _impl_.rmrsource_.Get();
+}
+inline void Message_StickerSyncRMRMessage::_internal_set_rmrsource(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.rmrsource_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_StickerSyncRMRMessage::_internal_mutable_rmrsource() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.rmrsource_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_StickerSyncRMRMessage::release_rmrsource() {
+  // @@protoc_insertion_point(field_release:proto.Message.StickerSyncRMRMessage.rmrSource)
+  if (!_internal_has_rmrsource()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.rmrsource_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rmrsource_.IsDefault()) {
+    _impl_.rmrsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_StickerSyncRMRMessage::set_allocated_rmrsource(std::string* rmrsource) {
+  if (rmrsource != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.rmrsource_.SetAllocated(rmrsource, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rmrsource_.IsDefault()) {
+    _impl_.rmrsource_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerSyncRMRMessage.rmrSource)
+}
+
+// optional int64 requestTimestamp = 3;
+inline bool Message_StickerSyncRMRMessage::_internal_has_requesttimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_StickerSyncRMRMessage::has_requesttimestamp() const {
+  return _internal_has_requesttimestamp();
+}
+inline void Message_StickerSyncRMRMessage::clear_requesttimestamp() {
+  _impl_.requesttimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t Message_StickerSyncRMRMessage::_internal_requesttimestamp() const {
+  return _impl_.requesttimestamp_;
+}
+inline int64_t Message_StickerSyncRMRMessage::requesttimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.requestTimestamp)
+  return _internal_requesttimestamp();
+}
+inline void Message_StickerSyncRMRMessage::_internal_set_requesttimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.requesttimestamp_ = value;
+}
+inline void Message_StickerSyncRMRMessage::set_requesttimestamp(int64_t value) {
+  _internal_set_requesttimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.requestTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// Message_TemplateButtonReplyMessage
+
+// optional string selectedId = 1;
+inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_TemplateButtonReplyMessage::has_selectedid() const {
+  return _internal_has_selectedid();
+}
+inline void Message_TemplateButtonReplyMessage::clear_selectedid() {
+  _impl_.selectedid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_TemplateButtonReplyMessage::selectedid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedId)
+  return _internal_selectedid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_TemplateButtonReplyMessage::set_selectedid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.selectedid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedId)
+}
+inline std::string* Message_TemplateButtonReplyMessage::mutable_selectedid() {
+  std::string* _s = _internal_mutable_selectedid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedId)
+  return _s;
+}
+inline const std::string& Message_TemplateButtonReplyMessage::_internal_selectedid() const {
+  return _impl_.selectedid_.Get();
+}
+inline void Message_TemplateButtonReplyMessage::_internal_set_selectedid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.selectedid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selectedid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.selectedid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_TemplateButtonReplyMessage::release_selectedid() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedId)
+  if (!_internal_has_selectedid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.selectedid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedid_.IsDefault()) {
+    _impl_.selectedid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_TemplateButtonReplyMessage::set_allocated_selectedid(std::string* selectedid) {
+  if (selectedid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.selectedid_.SetAllocated(selectedid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selectedid_.IsDefault()) {
+    _impl_.selectedid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedId)
+}
+
+// optional string selectedDisplayText = 2;
+inline bool Message_TemplateButtonReplyMessage::_internal_has_selecteddisplaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_TemplateButtonReplyMessage::has_selecteddisplaytext() const {
+  return _internal_has_selecteddisplaytext();
+}
+inline void Message_TemplateButtonReplyMessage::clear_selecteddisplaytext() {
+  _impl_.selecteddisplaytext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_TemplateButtonReplyMessage::selecteddisplaytext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
+  return _internal_selecteddisplaytext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_TemplateButtonReplyMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.selecteddisplaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
+}
+inline std::string* Message_TemplateButtonReplyMessage::mutable_selecteddisplaytext() {
+  std::string* _s = _internal_mutable_selecteddisplaytext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
+  return _s;
+}
+inline const std::string& Message_TemplateButtonReplyMessage::_internal_selecteddisplaytext() const {
+  return _impl_.selecteddisplaytext_.Get();
+}
+inline void Message_TemplateButtonReplyMessage::_internal_set_selecteddisplaytext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.selecteddisplaytext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selecteddisplaytext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.selecteddisplaytext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_TemplateButtonReplyMessage::release_selecteddisplaytext() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
+  if (!_internal_has_selecteddisplaytext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.selecteddisplaytext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selecteddisplaytext_.IsDefault()) {
+    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_TemplateButtonReplyMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) {
+  if (selecteddisplaytext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.selecteddisplaytext_.SetAllocated(selecteddisplaytext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.selecteddisplaytext_.IsDefault()) {
+    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
+}
+
+// optional .proto.ContextInfo contextInfo = 3;
+inline bool Message_TemplateButtonReplyMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_TemplateButtonReplyMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_TemplateButtonReplyMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_TemplateButtonReplyMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.contextInfo)
+  return _msg;
+}
+inline void Message_TemplateButtonReplyMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo)
+}
+
+// optional uint32 selectedIndex = 4;
+inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedindex() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_TemplateButtonReplyMessage::has_selectedindex() const {
+  return _internal_has_selectedindex();
+}
+inline void Message_TemplateButtonReplyMessage::clear_selectedindex() {
+  _impl_.selectedindex_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t Message_TemplateButtonReplyMessage::_internal_selectedindex() const {
+  return _impl_.selectedindex_;
+}
+inline uint32_t Message_TemplateButtonReplyMessage::selectedindex() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedIndex)
+  return _internal_selectedindex();
+}
+inline void Message_TemplateButtonReplyMessage::_internal_set_selectedindex(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.selectedindex_ = value;
+}
+inline void Message_TemplateButtonReplyMessage::set_selectedindex(uint32_t value) {
+  _internal_set_selectedindex(value);
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedIndex)
+}
+
+// -------------------------------------------------------------------
+
+// Message_TemplateMessage_FourRowTemplate
+
+// optional .proto.Message.HighlyStructuredMessage content = 6;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_content() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.content_ != nullptr);
+  return value;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_content() const {
+  return _internal_has_content();
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_content() {
+  if (_impl_.content_ != nullptr) _impl_.content_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_content() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.content_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::content() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.content)
+  return _internal_content();
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_content(
+    ::proto::Message_HighlyStructuredMessage* content) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.content_);
+  }
+  _impl_.content_ = content;
+  if (content) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content)
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_content() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_;
+  _impl_.content_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_content() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.content)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_;
+  _impl_.content_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_content() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.content_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.content_ = p;
+  }
+  return _impl_.content_;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_content() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_content();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.content)
+  return _msg;
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_allocated_content(::proto::Message_HighlyStructuredMessage* content) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.content_;
+  }
+  if (content) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(content);
+    if (message_arena != submessage_arena) {
+      content = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, content, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.content_ = content;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content)
+}
+
+// optional .proto.Message.HighlyStructuredMessage footer = 7;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_footer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr);
+  return value;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_footer() const {
+  return _internal_has_footer();
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_footer() {
+  if (_impl_.footer_ != nullptr) _impl_.footer_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_footer() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.footer_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::footer() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.footer)
+  return _internal_footer();
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_footer(
+    ::proto::Message_HighlyStructuredMessage* footer) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_);
+  }
+  _impl_.footer_ = footer;
+  if (footer) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer)
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_footer() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_;
+  _impl_.footer_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_footer() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.footer)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_;
+  _impl_.footer_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_footer() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.footer_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.footer_ = p;
+  }
+  return _impl_.footer_;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_footer() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_footer();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.footer)
+  return _msg;
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.footer_;
+  }
+  if (footer) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer);
+    if (message_arena != submessage_arena) {
+      footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, footer, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.footer_ = footer;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer)
+}
+
+// repeated .proto.TemplateButton buttons = 8;
+inline int Message_TemplateMessage_FourRowTemplate::_internal_buttons_size() const {
+  return _impl_.buttons_.size();
+}
+inline int Message_TemplateMessage_FourRowTemplate::buttons_size() const {
+  return _internal_buttons_size();
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_buttons() {
+  _impl_.buttons_.Clear();
+}
+inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::mutable_buttons(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.buttons)
+  return _impl_.buttons_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >*
+Message_TemplateMessage_FourRowTemplate::mutable_buttons() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.FourRowTemplate.buttons)
+  return &_impl_.buttons_;
+}
+inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::_internal_buttons(int index) const {
+  return _impl_.buttons_.Get(index);
+}
+inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::buttons(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.buttons)
+  return _internal_buttons(index);
+}
+inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::_internal_add_buttons() {
+  return _impl_.buttons_.Add();
+}
+inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::add_buttons() {
+  ::proto::TemplateButton* _add = _internal_add_buttons();
+  // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.FourRowTemplate.buttons)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >&
+Message_TemplateMessage_FourRowTemplate::buttons() const {
+  // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.FourRowTemplate.buttons)
+  return _impl_.buttons_;
+}
+
+// .proto.Message.DocumentMessage documentMessage = 1;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_documentmessage() const {
+  return title_case() == kDocumentMessage;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_documentmessage() const {
+  return _internal_has_documentmessage();
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_has_documentmessage() {
+  _impl_._oneof_case_[0] = kDocumentMessage;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_documentmessage() {
+  if (_internal_has_documentmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.documentmessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::release_documentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_title();
+    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::_internal_documentmessage() const {
+  return _internal_has_documentmessage()
+      ? *_impl_.title_.documentmessage_
+      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
+}
+inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::documentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+  return _internal_documentmessage();
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_documentmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_title();
+    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
+    _impl_.title_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  clear_title();
+  if (documentmessage) {
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_documentmessage() {
+  if (!_internal_has_documentmessage()) {
+    clear_title();
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.documentmessage_;
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::mutable_documentmessage() {
+  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
+  return _msg;
+}
+
+// .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_highlystructuredmessage() const {
+  return title_case() == kHighlyStructuredMessage;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_highlystructuredmessage() const {
+  return _internal_has_highlystructuredmessage();
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_has_highlystructuredmessage() {
+  _impl_._oneof_case_[0] = kHighlyStructuredMessage;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_highlystructuredmessage() {
+  if (_internal_has_highlystructuredmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.highlystructuredmessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_highlystructuredmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+  if (_internal_has_highlystructuredmessage()) {
+    clear_has_title();
+    ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.highlystructuredmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_highlystructuredmessage() const {
+  return _internal_has_highlystructuredmessage()
+      ? *_impl_.title_.highlystructuredmessage_
+      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage&>(::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::highlystructuredmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+  return _internal_highlystructuredmessage();
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_highlystructuredmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+  if (_internal_has_highlystructuredmessage()) {
+    clear_has_title();
+    ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_;
+    _impl_.title_.highlystructuredmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
+  clear_title();
+  if (highlystructuredmessage) {
+    set_has_highlystructuredmessage();
+    _impl_.title_.highlystructuredmessage_ = highlystructuredmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_highlystructuredmessage() {
+  if (!_internal_has_highlystructuredmessage()) {
+    clear_title();
+    set_has_highlystructuredmessage();
+    _impl_.title_.highlystructuredmessage_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.highlystructuredmessage_;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_highlystructuredmessage() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
+  return _msg;
+}
+
+// .proto.Message.ImageMessage imageMessage = 3;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_imagemessage() const {
+  return title_case() == kImageMessage;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_imagemessage() const {
+  return _internal_has_imagemessage();
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_has_imagemessage() {
+  _impl_._oneof_case_[0] = kImageMessage;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_imagemessage() {
+  if (_internal_has_imagemessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.imagemessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::release_imagemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_title();
+    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::_internal_imagemessage() const {
+  return _internal_has_imagemessage()
+      ? *_impl_.title_.imagemessage_
+      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::imagemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+  return _internal_imagemessage();
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_imagemessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_title();
+    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
+    _impl_.title_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  clear_title();
+  if (imagemessage) {
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_imagemessage() {
+  if (!_internal_has_imagemessage()) {
+    clear_title();
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.imagemessage_;
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::mutable_imagemessage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
+  return _msg;
+}
+
+// .proto.Message.VideoMessage videoMessage = 4;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_videomessage() const {
+  return title_case() == kVideoMessage;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_videomessage() const {
+  return _internal_has_videomessage();
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_has_videomessage() {
+  _impl_._oneof_case_[0] = kVideoMessage;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_videomessage() {
+  if (_internal_has_videomessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.videomessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::release_videomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_title();
+    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::_internal_videomessage() const {
+  return _internal_has_videomessage()
+      ? *_impl_.title_.videomessage_
+      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
+}
+inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::videomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+  return _internal_videomessage();
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_videomessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_title();
+    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
+    _impl_.title_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  clear_title();
+  if (videomessage) {
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_videomessage() {
+  if (!_internal_has_videomessage()) {
+    clear_title();
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.videomessage_;
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::mutable_videomessage() {
+  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
+  return _msg;
+}
+
+// .proto.Message.LocationMessage locationMessage = 5;
+inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_locationmessage() const {
+  return title_case() == kLocationMessage;
+}
+inline bool Message_TemplateMessage_FourRowTemplate::has_locationmessage() const {
+  return _internal_has_locationmessage();
+}
+inline void Message_TemplateMessage_FourRowTemplate::set_has_locationmessage() {
+  _impl_._oneof_case_[0] = kLocationMessage;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_locationmessage() {
+  if (_internal_has_locationmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.locationmessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::release_locationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_title();
+    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::_internal_locationmessage() const {
+  return _internal_has_locationmessage()
+      ? *_impl_.title_.locationmessage_
+      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
+}
+inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::locationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+  return _internal_locationmessage();
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_locationmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_title();
+    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
+    _impl_.title_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  clear_title();
+  if (locationmessage) {
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_locationmessage() {
+  if (!_internal_has_locationmessage()) {
+    clear_title();
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.locationmessage_;
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::mutable_locationmessage() {
+  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
+  return _msg;
+}
+
+inline bool Message_TemplateMessage_FourRowTemplate::has_title() const {
+  return title_case() != TITLE_NOT_SET;
+}
+inline void Message_TemplateMessage_FourRowTemplate::clear_has_title() {
+  _impl_._oneof_case_[0] = TITLE_NOT_SET;
+}
+inline Message_TemplateMessage_FourRowTemplate::TitleCase Message_TemplateMessage_FourRowTemplate::title_case() const {
+  return Message_TemplateMessage_FourRowTemplate::TitleCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_TemplateMessage_HydratedFourRowTemplate
+
+// optional string hydratedContentText = 6;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedcontenttext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedcontenttext() const {
+  return _internal_has_hydratedcontenttext();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedcontenttext() {
+  _impl_.hydratedcontenttext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedcontenttext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
+  return _internal_hydratedcontenttext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedcontenttext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.hydratedcontenttext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedcontenttext() {
+  std::string* _s = _internal_mutable_hydratedcontenttext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
+  return _s;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedcontenttext() const {
+  return _impl_.hydratedcontenttext_.Get();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedcontenttext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.hydratedcontenttext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedcontenttext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.hydratedcontenttext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedcontenttext() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
+  if (!_internal_has_hydratedcontenttext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.hydratedcontenttext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hydratedcontenttext_.IsDefault()) {
+    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedcontenttext(std::string* hydratedcontenttext) {
+  if (hydratedcontenttext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.hydratedcontenttext_.SetAllocated(hydratedcontenttext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hydratedcontenttext_.IsDefault()) {
+    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
+}
+
+// optional string hydratedFooterText = 7;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedfootertext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedfootertext() const {
+  return _internal_has_hydratedfootertext();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedfootertext() {
+  _impl_.hydratedfootertext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedfootertext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
+  return _internal_hydratedfootertext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedfootertext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.hydratedfootertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedfootertext() {
+  std::string* _s = _internal_mutable_hydratedfootertext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
+  return _s;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedfootertext() const {
+  return _impl_.hydratedfootertext_.Get();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedfootertext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.hydratedfootertext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedfootertext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.hydratedfootertext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedfootertext() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
+  if (!_internal_has_hydratedfootertext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.hydratedfootertext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hydratedfootertext_.IsDefault()) {
+    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedfootertext(std::string* hydratedfootertext) {
+  if (hydratedfootertext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.hydratedfootertext_.SetAllocated(hydratedfootertext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hydratedfootertext_.IsDefault()) {
+    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
+}
+
+// repeated .proto.HydratedTemplateButton hydratedButtons = 8;
+inline int Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons_size() const {
+  return _impl_.hydratedbuttons_.size();
+}
+inline int Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons_size() const {
+  return _internal_hydratedbuttons_size();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedbuttons() {
+  _impl_.hydratedbuttons_.Clear();
+}
+inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
+  return _impl_.hydratedbuttons_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >*
+Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
+  return &_impl_.hydratedbuttons_;
+}
+inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons(int index) const {
+  return _impl_.hydratedbuttons_.Get(index);
+}
+inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
+  return _internal_hydratedbuttons(index);
+}
+inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::_internal_add_hydratedbuttons() {
+  return _impl_.hydratedbuttons_.Add();
+}
+inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::add_hydratedbuttons() {
+  ::proto::HydratedTemplateButton* _add = _internal_add_hydratedbuttons();
+  // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >&
+Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons() const {
+  // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
+  return _impl_.hydratedbuttons_;
+}
+
+// optional string templateId = 9;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_templateid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_templateid() const {
+  return _internal_has_templateid();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_templateid() {
+  _impl_.templateid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::templateid() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
+  return _internal_templateid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_TemplateMessage_HydratedFourRowTemplate::set_templateid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.templateid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_templateid() {
+  std::string* _s = _internal_mutable_templateid();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
+  return _s;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_templateid() const {
+  return _impl_.templateid_.Get();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_templateid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.templateid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_templateid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.templateid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_templateid() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
+  if (!_internal_has_templateid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.templateid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.templateid_.IsDefault()) {
+    _impl_.templateid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_templateid(std::string* templateid) {
+  if (templateid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.templateid_.SetAllocated(templateid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.templateid_.IsDefault()) {
+    _impl_.templateid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
+}
+
+// .proto.Message.DocumentMessage documentMessage = 1;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_documentmessage() const {
+  return title_case() == kDocumentMessage;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_documentmessage() const {
+  return _internal_has_documentmessage();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_documentmessage() {
+  _impl_._oneof_case_[0] = kDocumentMessage;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_documentmessage() {
+  if (_internal_has_documentmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.documentmessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_documentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_title();
+    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_documentmessage() const {
+  return _internal_has_documentmessage()
+      ? *_impl_.title_.documentmessage_
+      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
+}
+inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::documentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+  return _internal_documentmessage();
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_documentmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+  if (_internal_has_documentmessage()) {
+    clear_has_title();
+    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
+    _impl_.title_.documentmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  clear_title();
+  if (documentmessage) {
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = documentmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_documentmessage() {
+  if (!_internal_has_documentmessage()) {
+    clear_title();
+    set_has_documentmessage();
+    _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.documentmessage_;
+}
+inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_documentmessage() {
+  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
+  return _msg;
+}
+
+// string hydratedTitleText = 2;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedtitletext() const {
+  return title_case() == kHydratedTitleText;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedtitletext() const {
+  return _internal_has_hydratedtitletext();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_hydratedtitletext() {
+  _impl_._oneof_case_[0] = kHydratedTitleText;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedtitletext() {
+  if (_internal_has_hydratedtitletext()) {
+    _impl_.title_.hydratedtitletext_.Destroy();
+    clear_has_title();
+  }
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedtitletext() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
+  return _internal_hydratedtitletext();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedtitletext(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_hydratedtitletext()) {
+    clear_title();
+    set_has_hydratedtitletext();
+    _impl_.title_.hydratedtitletext_.InitDefault();
+  }
+  _impl_.title_.hydratedtitletext_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedtitletext() {
+  std::string* _s = _internal_mutable_hydratedtitletext();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
+  return _s;
+}
+inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedtitletext() const {
+  if (_internal_has_hydratedtitletext()) {
+    return _impl_.title_.hydratedtitletext_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedtitletext(const std::string& value) {
+  if (!_internal_has_hydratedtitletext()) {
+    clear_title();
+    set_has_hydratedtitletext();
+    _impl_.title_.hydratedtitletext_.InitDefault();
+  }
+  _impl_.title_.hydratedtitletext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedtitletext() {
+  if (!_internal_has_hydratedtitletext()) {
+    clear_title();
+    set_has_hydratedtitletext();
+    _impl_.title_.hydratedtitletext_.InitDefault();
+  }
+  return _impl_.title_.hydratedtitletext_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedtitletext() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
+  if (_internal_has_hydratedtitletext()) {
+    clear_has_title();
+    return _impl_.title_.hydratedtitletext_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedtitletext(std::string* hydratedtitletext) {
+  if (has_title()) {
+    clear_title();
+  }
+  if (hydratedtitletext != nullptr) {
+    set_has_hydratedtitletext();
+    _impl_.title_.hydratedtitletext_.InitAllocated(hydratedtitletext, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
+}
+
+// .proto.Message.ImageMessage imageMessage = 3;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_imagemessage() const {
+  return title_case() == kImageMessage;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_imagemessage() const {
+  return _internal_has_imagemessage();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_imagemessage() {
+  _impl_._oneof_case_[0] = kImageMessage;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_imagemessage() {
+  if (_internal_has_imagemessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.imagemessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_imagemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_title();
+    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_imagemessage() const {
+  return _internal_has_imagemessage()
+      ? *_impl_.title_.imagemessage_
+      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::imagemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+  return _internal_imagemessage();
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_imagemessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+  if (_internal_has_imagemessage()) {
+    clear_has_title();
+    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
+    _impl_.title_.imagemessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  clear_title();
+  if (imagemessage) {
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = imagemessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_imagemessage() {
+  if (!_internal_has_imagemessage()) {
+    clear_title();
+    set_has_imagemessage();
+    _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.imagemessage_;
+}
+inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_imagemessage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
+  return _msg;
+}
+
+// .proto.Message.VideoMessage videoMessage = 4;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_videomessage() const {
+  return title_case() == kVideoMessage;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_videomessage() const {
+  return _internal_has_videomessage();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_videomessage() {
+  _impl_._oneof_case_[0] = kVideoMessage;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_videomessage() {
+  if (_internal_has_videomessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.videomessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_videomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_title();
+    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_videomessage() const {
+  return _internal_has_videomessage()
+      ? *_impl_.title_.videomessage_
+      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
+}
+inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::videomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+  return _internal_videomessage();
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_videomessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+  if (_internal_has_videomessage()) {
+    clear_has_title();
+    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
+    _impl_.title_.videomessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  clear_title();
+  if (videomessage) {
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = videomessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_videomessage() {
+  if (!_internal_has_videomessage()) {
+    clear_title();
+    set_has_videomessage();
+    _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.videomessage_;
+}
+inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_videomessage() {
+  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
+  return _msg;
+}
+
+// .proto.Message.LocationMessage locationMessage = 5;
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_locationmessage() const {
+  return title_case() == kLocationMessage;
+}
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_locationmessage() const {
+  return _internal_has_locationmessage();
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_locationmessage() {
+  _impl_._oneof_case_[0] = kLocationMessage;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_locationmessage() {
+  if (_internal_has_locationmessage()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.title_.locationmessage_;
+    }
+    clear_has_title();
+  }
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_locationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_title();
+    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.title_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_locationmessage() const {
+  return _internal_has_locationmessage()
+      ? *_impl_.title_.locationmessage_
+      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
+}
+inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::locationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+  return _internal_locationmessage();
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_locationmessage() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+  if (_internal_has_locationmessage()) {
+    clear_has_title();
+    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
+    _impl_.title_.locationmessage_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  clear_title();
+  if (locationmessage) {
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = locationmessage;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_locationmessage() {
+  if (!_internal_has_locationmessage()) {
+    clear_title();
+    set_has_locationmessage();
+    _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
+  }
+  return _impl_.title_.locationmessage_;
+}
+inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_locationmessage() {
+  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
+  return _msg;
+}
+
+inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_title() const {
+  return title_case() != TITLE_NOT_SET;
+}
+inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_has_title() {
+  _impl_._oneof_case_[0] = TITLE_NOT_SET;
+}
+inline Message_TemplateMessage_HydratedFourRowTemplate::TitleCase Message_TemplateMessage_HydratedFourRowTemplate::title_case() const {
+  return Message_TemplateMessage_HydratedFourRowTemplate::TitleCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_TemplateMessage
+
+// optional .proto.ContextInfo contextInfo = 3;
+inline bool Message_TemplateMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_TemplateMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_TemplateMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::ContextInfo& Message_TemplateMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_TemplateMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_TemplateMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_TemplateMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_TemplateMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_TemplateMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_TemplateMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.contextInfo)
+  return _msg;
+}
+inline void Message_TemplateMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.contextInfo)
+}
+
+// optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
+inline bool Message_TemplateMessage::_internal_has_hydratedtemplate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.hydratedtemplate_ != nullptr);
+  return value;
+}
+inline bool Message_TemplateMessage::has_hydratedtemplate() const {
+  return _internal_has_hydratedtemplate();
+}
+inline void Message_TemplateMessage::clear_hydratedtemplate() {
+  if (_impl_.hydratedtemplate_ != nullptr) _impl_.hydratedtemplate_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedtemplate() const {
+  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate* p = _impl_.hydratedtemplate_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(
+      ::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
+}
+inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedtemplate() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedTemplate)
+  return _internal_hydratedtemplate();
+}
+inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedtemplate(
+    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedtemplate_);
+  }
+  _impl_.hydratedtemplate_ = hydratedtemplate;
+  if (hydratedtemplate) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedTemplate)
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedtemplate() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_;
+  _impl_.hydratedtemplate_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedtemplate() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedTemplate)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_;
+  _impl_.hydratedtemplate_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedtemplate() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.hydratedtemplate_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(GetArenaForAllocation());
+    _impl_.hydratedtemplate_ = p;
+  }
+  return _impl_.hydratedtemplate_;
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedtemplate() {
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedtemplate();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedTemplate)
+  return _msg;
+}
+inline void Message_TemplateMessage::set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.hydratedtemplate_;
+  }
+  if (hydratedtemplate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedtemplate);
+    if (message_arena != submessage_arena) {
+      hydratedtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, hydratedtemplate, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.hydratedtemplate_ = hydratedtemplate;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedTemplate)
+}
+
+// .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
+inline bool Message_TemplateMessage::_internal_has_fourrowtemplate() const {
+  return format_case() == kFourRowTemplate;
+}
+inline bool Message_TemplateMessage::has_fourrowtemplate() const {
+  return _internal_has_fourrowtemplate();
+}
+inline void Message_TemplateMessage::set_has_fourrowtemplate() {
+  _impl_._oneof_case_[0] = kFourRowTemplate;
+}
+inline void Message_TemplateMessage::clear_fourrowtemplate() {
+  if (_internal_has_fourrowtemplate()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.format_.fourrowtemplate_;
+    }
+    clear_has_format();
+  }
+}
+inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::release_fourrowtemplate() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.fourRowTemplate)
+  if (_internal_has_fourrowtemplate()) {
+    clear_has_format();
+    ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.format_.fourrowtemplate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::_internal_fourrowtemplate() const {
+  return _internal_has_fourrowtemplate()
+      ? *_impl_.format_.fourrowtemplate_
+      : reinterpret_cast< ::proto::Message_TemplateMessage_FourRowTemplate&>(::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_);
+}
+inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::fourrowtemplate() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.fourRowTemplate)
+  return _internal_fourrowtemplate();
+}
+inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::unsafe_arena_release_fourrowtemplate() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.fourRowTemplate)
+  if (_internal_has_fourrowtemplate()) {
+    clear_has_format();
+    ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_;
+    _impl_.format_.fourrowtemplate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage::unsafe_arena_set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) {
+  clear_format();
+  if (fourrowtemplate) {
+    set_has_fourrowtemplate();
+    _impl_.format_.fourrowtemplate_ = fourrowtemplate;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.fourRowTemplate)
+}
+inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::_internal_mutable_fourrowtemplate() {
+  if (!_internal_has_fourrowtemplate()) {
+    clear_format();
+    set_has_fourrowtemplate();
+    _impl_.format_.fourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(GetArenaForAllocation());
+  }
+  return _impl_.format_.fourrowtemplate_;
+}
+inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::mutable_fourrowtemplate() {
+  ::proto::Message_TemplateMessage_FourRowTemplate* _msg = _internal_mutable_fourrowtemplate();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.fourRowTemplate)
+  return _msg;
+}
+
+// .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
+inline bool Message_TemplateMessage::_internal_has_hydratedfourrowtemplate() const {
+  return format_case() == kHydratedFourRowTemplate;
+}
+inline bool Message_TemplateMessage::has_hydratedfourrowtemplate() const {
+  return _internal_has_hydratedfourrowtemplate();
+}
+inline void Message_TemplateMessage::set_has_hydratedfourrowtemplate() {
+  _impl_._oneof_case_[0] = kHydratedFourRowTemplate;
+}
+inline void Message_TemplateMessage::clear_hydratedfourrowtemplate() {
+  if (_internal_has_hydratedfourrowtemplate()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.format_.hydratedfourrowtemplate_;
+    }
+    clear_has_format();
+  }
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedfourrowtemplate() {
+  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+  if (_internal_has_hydratedfourrowtemplate()) {
+    clear_has_format();
+    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.format_.hydratedfourrowtemplate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedfourrowtemplate() const {
+  return _internal_has_hydratedfourrowtemplate()
+      ? *_impl_.format_.hydratedfourrowtemplate_
+      : reinterpret_cast< ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
+}
+inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedfourrowtemplate() const {
+  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+  return _internal_hydratedfourrowtemplate();
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedfourrowtemplate() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+  if (_internal_has_hydratedfourrowtemplate()) {
+    clear_has_format();
+    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_;
+    _impl_.format_.hydratedfourrowtemplate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) {
+  clear_format();
+  if (hydratedfourrowtemplate) {
+    set_has_hydratedfourrowtemplate();
+    _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedfourrowtemplate() {
+  if (!_internal_has_hydratedfourrowtemplate()) {
+    clear_format();
+    set_has_hydratedfourrowtemplate();
+    _impl_.format_.hydratedfourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(GetArenaForAllocation());
+  }
+  return _impl_.format_.hydratedfourrowtemplate_;
+}
+inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedfourrowtemplate() {
+  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedfourrowtemplate();
+  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedFourRowTemplate)
+  return _msg;
+}
+
+inline bool Message_TemplateMessage::has_format() const {
+  return format_case() != FORMAT_NOT_SET;
+}
+inline void Message_TemplateMessage::clear_has_format() {
+  _impl_._oneof_case_[0] = FORMAT_NOT_SET;
+}
+inline Message_TemplateMessage::FormatCase Message_TemplateMessage::format_case() const {
+  return Message_TemplateMessage::FormatCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Message_VideoMessage
+
+// optional string url = 1;
+inline bool Message_VideoMessage::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_url() const {
+  return _internal_has_url();
+}
+inline void Message_VideoMessage::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message_VideoMessage::url() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.url)
+}
+inline std::string* Message_VideoMessage::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.url)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void Message_VideoMessage::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_url() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.url)
+}
+
+// optional string mimetype = 2;
+inline bool Message_VideoMessage::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void Message_VideoMessage::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Message_VideoMessage::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mimetype)
+}
+inline std::string* Message_VideoMessage::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mimetype)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void Message_VideoMessage::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mimetype)
+}
+
+// optional bytes fileSha256 = 3;
+inline bool Message_VideoMessage::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void Message_VideoMessage::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& Message_VideoMessage::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileSha256)
+}
+inline std::string* Message_VideoMessage::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileSha256)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void Message_VideoMessage::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileSha256)
+}
+
+// optional uint64 fileLength = 4;
+inline bool Message_VideoMessage::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void Message_VideoMessage::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline uint64_t Message_VideoMessage::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t Message_VideoMessage::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileLength)
+  return _internal_filelength();
+}
+inline void Message_VideoMessage::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.filelength_ = value;
+}
+inline void Message_VideoMessage::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileLength)
+}
+
+// optional uint32 seconds = 5;
+inline bool Message_VideoMessage::_internal_has_seconds() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_seconds() const {
+  return _internal_has_seconds();
+}
+inline void Message_VideoMessage::clear_seconds() {
+  _impl_.seconds_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline uint32_t Message_VideoMessage::_internal_seconds() const {
+  return _impl_.seconds_;
+}
+inline uint32_t Message_VideoMessage::seconds() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.seconds)
+  return _internal_seconds();
+}
+inline void Message_VideoMessage::_internal_set_seconds(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.seconds_ = value;
+}
+inline void Message_VideoMessage::set_seconds(uint32_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.seconds)
+}
+
+// optional bytes mediaKey = 6;
+inline bool Message_VideoMessage::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void Message_VideoMessage::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& Message_VideoMessage::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKey)
+}
+inline std::string* Message_VideoMessage::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mediaKey)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void Message_VideoMessage::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mediaKey)
+}
+
+// optional string caption = 7;
+inline bool Message_VideoMessage::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_caption() const {
+  return _internal_has_caption();
+}
+inline void Message_VideoMessage::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& Message_VideoMessage::caption() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.caption)
+}
+inline std::string* Message_VideoMessage::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.caption)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void Message_VideoMessage::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.caption)
+}
+
+// optional bool gifPlayback = 8;
+inline bool Message_VideoMessage::_internal_has_gifplayback() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_gifplayback() const {
+  return _internal_has_gifplayback();
+}
+inline void Message_VideoMessage::clear_gifplayback() {
+  _impl_.gifplayback_ = false;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline bool Message_VideoMessage::_internal_gifplayback() const {
+  return _impl_.gifplayback_;
+}
+inline bool Message_VideoMessage::gifplayback() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifPlayback)
+  return _internal_gifplayback();
+}
+inline void Message_VideoMessage::_internal_set_gifplayback(bool value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.gifplayback_ = value;
+}
+inline void Message_VideoMessage::set_gifplayback(bool value) {
+  _internal_set_gifplayback(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifPlayback)
+}
+
+// optional uint32 height = 9;
+inline bool Message_VideoMessage::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_height() const {
+  return _internal_has_height();
+}
+inline void Message_VideoMessage::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline uint32_t Message_VideoMessage::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t Message_VideoMessage::height() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.height)
+  return _internal_height();
+}
+inline void Message_VideoMessage::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.height_ = value;
+}
+inline void Message_VideoMessage::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.height)
+}
+
+// optional uint32 width = 10;
+inline bool Message_VideoMessage::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_width() const {
+  return _internal_has_width();
+}
+inline void Message_VideoMessage::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline uint32_t Message_VideoMessage::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t Message_VideoMessage::width() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.width)
+  return _internal_width();
+}
+inline void Message_VideoMessage::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.width_ = value;
+}
+inline void Message_VideoMessage::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.width)
+}
+
+// optional bytes fileEncSha256 = 11;
+inline bool Message_VideoMessage::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void Message_VideoMessage::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& Message_VideoMessage::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileEncSha256)
+}
+inline std::string* Message_VideoMessage::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileEncSha256)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void Message_VideoMessage::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileEncSha256)
+}
+
+// repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
+inline int Message_VideoMessage::_internal_interactiveannotations_size() const {
+  return _impl_.interactiveannotations_.size();
+}
+inline int Message_VideoMessage::interactiveannotations_size() const {
+  return _internal_interactiveannotations_size();
+}
+inline void Message_VideoMessage::clear_interactiveannotations() {
+  _impl_.interactiveannotations_.Clear();
+}
+inline ::proto::InteractiveAnnotation* Message_VideoMessage::mutable_interactiveannotations(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.interactiveAnnotations)
+  return _impl_.interactiveannotations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
+Message_VideoMessage::mutable_interactiveannotations() {
+  // @@protoc_insertion_point(field_mutable_list:proto.Message.VideoMessage.interactiveAnnotations)
+  return &_impl_.interactiveannotations_;
+}
+inline const ::proto::InteractiveAnnotation& Message_VideoMessage::_internal_interactiveannotations(int index) const {
+  return _impl_.interactiveannotations_.Get(index);
+}
+inline const ::proto::InteractiveAnnotation& Message_VideoMessage::interactiveannotations(int index) const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.interactiveAnnotations)
+  return _internal_interactiveannotations(index);
+}
+inline ::proto::InteractiveAnnotation* Message_VideoMessage::_internal_add_interactiveannotations() {
+  return _impl_.interactiveannotations_.Add();
+}
+inline ::proto::InteractiveAnnotation* Message_VideoMessage::add_interactiveannotations() {
+  ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations();
+  // @@protoc_insertion_point(field_add:proto.Message.VideoMessage.interactiveAnnotations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
+Message_VideoMessage::interactiveannotations() const {
+  // @@protoc_insertion_point(field_list:proto.Message.VideoMessage.interactiveAnnotations)
+  return _impl_.interactiveannotations_;
+}
+
+// optional string directPath = 13;
+inline bool Message_VideoMessage::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void Message_VideoMessage::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& Message_VideoMessage::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.directPath)
+}
+inline std::string* Message_VideoMessage::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.directPath)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void Message_VideoMessage::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.directPath)
+}
+
+// optional int64 mediaKeyTimestamp = 14;
+inline bool Message_VideoMessage::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void Message_VideoMessage::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline int64_t Message_VideoMessage::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t Message_VideoMessage::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void Message_VideoMessage::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void Message_VideoMessage::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKeyTimestamp)
+}
+
+// optional bytes jpegThumbnail = 16;
+inline bool Message_VideoMessage::_internal_has_jpegthumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_jpegthumbnail() const {
+  return _internal_has_jpegthumbnail();
+}
+inline void Message_VideoMessage::clear_jpegthumbnail() {
+  _impl_.jpegthumbnail_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& Message_VideoMessage::jpegthumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.jpegThumbnail)
+  return _internal_jpegthumbnail();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.jpegThumbnail)
+}
+inline std::string* Message_VideoMessage::mutable_jpegthumbnail() {
+  std::string* _s = _internal_mutable_jpegthumbnail();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.jpegThumbnail)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_jpegthumbnail() const {
+  return _impl_.jpegthumbnail_.Get();
+}
+inline void Message_VideoMessage::_internal_set_jpegthumbnail(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_jpegthumbnail() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_jpegthumbnail() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.jpegThumbnail)
+  if (!_internal_has_jpegthumbnail()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.jpegthumbnail_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
+  if (jpegthumbnail != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.jpegthumbnail_.IsDefault()) {
+    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.jpegThumbnail)
+}
+
+// optional .proto.ContextInfo contextInfo = 17;
+inline bool Message_VideoMessage::_internal_has_contextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
+  return value;
+}
+inline bool Message_VideoMessage::has_contextinfo() const {
+  return _internal_has_contextinfo();
+}
+inline void Message_VideoMessage::clear_contextinfo() {
+  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::ContextInfo& Message_VideoMessage::_internal_contextinfo() const {
+  const ::proto::ContextInfo* p = _impl_.contextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
+      ::proto::_ContextInfo_default_instance_);
+}
+inline const ::proto::ContextInfo& Message_VideoMessage::contextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.contextInfo)
+  return _internal_contextinfo();
+}
+inline void Message_VideoMessage::unsafe_arena_set_allocated_contextinfo(
+    ::proto::ContextInfo* contextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
+  }
+  _impl_.contextinfo_ = contextinfo;
+  if (contextinfo) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.VideoMessage.contextInfo)
+}
+inline ::proto::ContextInfo* Message_VideoMessage::release_contextinfo() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ContextInfo* Message_VideoMessage::unsafe_arena_release_contextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.contextInfo)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::ContextInfo* temp = _impl_.contextinfo_;
+  _impl_.contextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::ContextInfo* Message_VideoMessage::_internal_mutable_contextinfo() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.contextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
+    _impl_.contextinfo_ = p;
+  }
+  return _impl_.contextinfo_;
+}
+inline ::proto::ContextInfo* Message_VideoMessage::mutable_contextinfo() {
+  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.contextInfo)
+  return _msg;
+}
+inline void Message_VideoMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contextinfo_;
+  }
+  if (contextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
+    if (message_arena != submessage_arena) {
+      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.contextinfo_ = contextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.contextInfo)
+}
+
+// optional bytes streamingSidecar = 18;
+inline bool Message_VideoMessage::_internal_has_streamingsidecar() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_streamingsidecar() const {
+  return _internal_has_streamingsidecar();
+}
+inline void Message_VideoMessage::clear_streamingsidecar() {
+  _impl_.streamingsidecar_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& Message_VideoMessage::streamingsidecar() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.streamingSidecar)
+  return _internal_streamingsidecar();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.streamingsidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.streamingSidecar)
+}
+inline std::string* Message_VideoMessage::mutable_streamingsidecar() {
+  std::string* _s = _internal_mutable_streamingsidecar();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.streamingSidecar)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_streamingsidecar() const {
+  return _impl_.streamingsidecar_.Get();
+}
+inline void Message_VideoMessage::_internal_set_streamingsidecar(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.streamingsidecar_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_streamingsidecar() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_streamingsidecar() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.streamingSidecar)
+  if (!_internal_has_streamingsidecar()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.streamingsidecar_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.streamingsidecar_.IsDefault()) {
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) {
+  if (streamingsidecar != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.streamingsidecar_.IsDefault()) {
+    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.streamingSidecar)
+}
+
+// optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
+inline bool Message_VideoMessage::_internal_has_gifattribution() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_gifattribution() const {
+  return _internal_has_gifattribution();
+}
+inline void Message_VideoMessage::clear_gifattribution() {
+  _impl_.gifattribution_ = 0;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::_internal_gifattribution() const {
+  return static_cast< ::proto::Message_VideoMessage_Attribution >(_impl_.gifattribution_);
+}
+inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::gifattribution() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifAttribution)
+  return _internal_gifattribution();
+}
+inline void Message_VideoMessage::_internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value) {
+  assert(::proto::Message_VideoMessage_Attribution_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.gifattribution_ = value;
+}
+inline void Message_VideoMessage::set_gifattribution(::proto::Message_VideoMessage_Attribution value) {
+  _internal_set_gifattribution(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifAttribution)
+}
+
+// optional bool viewOnce = 20;
+inline bool Message_VideoMessage::_internal_has_viewonce() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_viewonce() const {
+  return _internal_has_viewonce();
+}
+inline void Message_VideoMessage::clear_viewonce() {
+  _impl_.viewonce_ = false;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline bool Message_VideoMessage::_internal_viewonce() const {
+  return _impl_.viewonce_;
+}
+inline bool Message_VideoMessage::viewonce() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.viewOnce)
+  return _internal_viewonce();
+}
+inline void Message_VideoMessage::_internal_set_viewonce(bool value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.viewonce_ = value;
+}
+inline void Message_VideoMessage::set_viewonce(bool value) {
+  _internal_set_viewonce(value);
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.viewOnce)
+}
+
+// optional string thumbnailDirectPath = 21;
+inline bool Message_VideoMessage::_internal_has_thumbnaildirectpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_thumbnaildirectpath() const {
+  return _internal_has_thumbnaildirectpath();
+}
+inline void Message_VideoMessage::clear_thumbnaildirectpath() {
+  _impl_.thumbnaildirectpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& Message_VideoMessage::thumbnaildirectpath() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailDirectPath)
+  return _internal_thumbnaildirectpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailDirectPath)
+}
+inline std::string* Message_VideoMessage::mutable_thumbnaildirectpath() {
+  std::string* _s = _internal_mutable_thumbnaildirectpath();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailDirectPath)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_thumbnaildirectpath() const {
+  return _impl_.thumbnaildirectpath_.Get();
+}
+inline void Message_VideoMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_thumbnaildirectpath() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_thumbnaildirectpath() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailDirectPath)
+  if (!_internal_has_thumbnaildirectpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.thumbnaildirectpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
+  if (thumbnaildirectpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnaildirectpath_.IsDefault()) {
+    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailDirectPath)
+}
+
+// optional bytes thumbnailSha256 = 22;
+inline bool Message_VideoMessage::_internal_has_thumbnailsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_thumbnailsha256() const {
+  return _internal_has_thumbnailsha256();
+}
+inline void Message_VideoMessage::clear_thumbnailsha256() {
+  _impl_.thumbnailsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& Message_VideoMessage::thumbnailsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailSha256)
+  return _internal_thumbnailsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailSha256)
+}
+inline std::string* Message_VideoMessage::mutable_thumbnailsha256() {
+  std::string* _s = _internal_mutable_thumbnailsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailSha256)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_thumbnailsha256() const {
+  return _impl_.thumbnailsha256_.Get();
+}
+inline void Message_VideoMessage::_internal_set_thumbnailsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_thumbnailsha256() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_thumbnailsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailSha256)
+  if (!_internal_has_thumbnailsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.thumbnailsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
+  if (thumbnailsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailsha256_.IsDefault()) {
+    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailSha256)
+}
+
+// optional bytes thumbnailEncSha256 = 23;
+inline bool Message_VideoMessage::_internal_has_thumbnailencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_thumbnailencsha256() const {
+  return _internal_has_thumbnailencsha256();
+}
+inline void Message_VideoMessage::clear_thumbnailencsha256() {
+  _impl_.thumbnailencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& Message_VideoMessage::thumbnailencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailEncSha256)
+  return _internal_thumbnailencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailEncSha256)
+}
+inline std::string* Message_VideoMessage::mutable_thumbnailencsha256() {
+  std::string* _s = _internal_mutable_thumbnailencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailEncSha256)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_thumbnailencsha256() const {
+  return _impl_.thumbnailencsha256_.Get();
+}
+inline void Message_VideoMessage::_internal_set_thumbnailencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_thumbnailencsha256() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_thumbnailencsha256() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailEncSha256)
+  if (!_internal_has_thumbnailencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.thumbnailencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
+  if (thumbnailencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.thumbnailencsha256_.IsDefault()) {
+    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailEncSha256)
+}
+
+// optional string staticUrl = 24;
+inline bool Message_VideoMessage::_internal_has_staticurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool Message_VideoMessage::has_staticurl() const {
+  return _internal_has_staticurl();
+}
+inline void Message_VideoMessage::clear_staticurl() {
+  _impl_.staticurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const std::string& Message_VideoMessage::staticurl() const {
+  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.staticUrl)
+  return _internal_staticurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message_VideoMessage::set_staticurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00001000u;
+ _impl_.staticurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.staticUrl)
+}
+inline std::string* Message_VideoMessage::mutable_staticurl() {
+  std::string* _s = _internal_mutable_staticurl();
+  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.staticUrl)
+  return _s;
+}
+inline const std::string& Message_VideoMessage::_internal_staticurl() const {
+  return _impl_.staticurl_.Get();
+}
+inline void Message_VideoMessage::_internal_set_staticurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.staticurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::_internal_mutable_staticurl() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  return _impl_.staticurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message_VideoMessage::release_staticurl() {
+  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.staticUrl)
+  if (!_internal_has_staticurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  auto* p = _impl_.staticurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.staticurl_.IsDefault()) {
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message_VideoMessage::set_allocated_staticurl(std::string* staticurl) {
+  if (staticurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.staticurl_.IsDefault()) {
+    _impl_.staticurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.staticUrl)
+}
+
+// -------------------------------------------------------------------
+
+// Message
+
+// optional string conversation = 1;
+inline bool Message::_internal_has_conversation() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Message::has_conversation() const {
+  return _internal_has_conversation();
+}
+inline void Message::clear_conversation() {
+  _impl_.conversation_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Message::conversation() const {
+  // @@protoc_insertion_point(field_get:proto.Message.conversation)
+  return _internal_conversation();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Message::set_conversation(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.conversation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Message.conversation)
+}
+inline std::string* Message::mutable_conversation() {
+  std::string* _s = _internal_mutable_conversation();
+  // @@protoc_insertion_point(field_mutable:proto.Message.conversation)
+  return _s;
+}
+inline const std::string& Message::_internal_conversation() const {
+  return _impl_.conversation_.Get();
+}
+inline void Message::_internal_set_conversation(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.conversation_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Message::_internal_mutable_conversation() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.conversation_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Message::release_conversation() {
+  // @@protoc_insertion_point(field_release:proto.Message.conversation)
+  if (!_internal_has_conversation()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.conversation_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversation_.IsDefault()) {
+    _impl_.conversation_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Message::set_allocated_conversation(std::string* conversation) {
+  if (conversation != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.conversation_.SetAllocated(conversation, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.conversation_.IsDefault()) {
+    _impl_.conversation_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.conversation)
+}
+
+// optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+inline bool Message::_internal_has_senderkeydistributionmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.senderkeydistributionmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_senderkeydistributionmessage() const {
+  return _internal_has_senderkeydistributionmessage();
+}
+inline void Message::clear_senderkeydistributionmessage() {
+  if (_impl_.senderkeydistributionmessage_ != nullptr) _impl_.senderkeydistributionmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_senderkeydistributionmessage() const {
+  const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.senderkeydistributionmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SenderKeyDistributionMessage&>(
+      ::proto::_Message_SenderKeyDistributionMessage_default_instance_);
+}
+inline const ::proto::Message_SenderKeyDistributionMessage& Message::senderkeydistributionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.senderKeyDistributionMessage)
+  return _internal_senderkeydistributionmessage();
+}
+inline void Message::unsafe_arena_set_allocated_senderkeydistributionmessage(
+    ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderkeydistributionmessage_);
+  }
+  _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage;
+  if (senderkeydistributionmessage) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.senderKeyDistributionMessage)
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::release_senderkeydistributionmessage() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_;
+  _impl_.senderkeydistributionmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_senderkeydistributionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.senderKeyDistributionMessage)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_;
+  _impl_.senderkeydistributionmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_senderkeydistributionmessage() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.senderkeydistributionmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation());
+    _impl_.senderkeydistributionmessage_ = p;
+  }
+  return _impl_.senderkeydistributionmessage_;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_senderkeydistributionmessage() {
+  ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_senderkeydistributionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.senderKeyDistributionMessage)
+  return _msg;
+}
+inline void Message::set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.senderkeydistributionmessage_;
+  }
+  if (senderkeydistributionmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderkeydistributionmessage);
+    if (message_arena != submessage_arena) {
+      senderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, senderkeydistributionmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.senderKeyDistributionMessage)
+}
+
+// optional .proto.Message.ImageMessage imageMessage = 3;
+inline bool Message::_internal_has_imagemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.imagemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_imagemessage() const {
+  return _internal_has_imagemessage();
+}
+inline void Message::clear_imagemessage() {
+  if (_impl_.imagemessage_ != nullptr) _impl_.imagemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message_ImageMessage& Message::_internal_imagemessage() const {
+  const ::proto::Message_ImageMessage* p = _impl_.imagemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
+      ::proto::_Message_ImageMessage_default_instance_);
+}
+inline const ::proto::Message_ImageMessage& Message::imagemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.imageMessage)
+  return _internal_imagemessage();
+}
+inline void Message::unsafe_arena_set_allocated_imagemessage(
+    ::proto::Message_ImageMessage* imagemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.imagemessage_);
+  }
+  _impl_.imagemessage_ = imagemessage;
+  if (imagemessage) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.imageMessage)
+}
+inline ::proto::Message_ImageMessage* Message::release_imagemessage() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ImageMessage* temp = _impl_.imagemessage_;
+  _impl_.imagemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message::unsafe_arena_release_imagemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.imageMessage)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message_ImageMessage* temp = _impl_.imagemessage_;
+  _impl_.imagemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ImageMessage* Message::_internal_mutable_imagemessage() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.imagemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
+    _impl_.imagemessage_ = p;
+  }
+  return _impl_.imagemessage_;
+}
+inline ::proto::Message_ImageMessage* Message::mutable_imagemessage() {
+  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.imageMessage)
+  return _msg;
+}
+inline void Message::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.imagemessage_;
+  }
+  if (imagemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
+    if (message_arena != submessage_arena) {
+      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, imagemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.imagemessage_ = imagemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.imageMessage)
+}
+
+// optional .proto.Message.ContactMessage contactMessage = 4;
+inline bool Message::_internal_has_contactmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contactmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_contactmessage() const {
+  return _internal_has_contactmessage();
+}
+inline void Message::clear_contactmessage() {
+  if (_impl_.contactmessage_ != nullptr) _impl_.contactmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::Message_ContactMessage& Message::_internal_contactmessage() const {
+  const ::proto::Message_ContactMessage* p = _impl_.contactmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ContactMessage&>(
+      ::proto::_Message_ContactMessage_default_instance_);
+}
+inline const ::proto::Message_ContactMessage& Message::contactmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.contactMessage)
+  return _internal_contactmessage();
+}
+inline void Message::unsafe_arena_set_allocated_contactmessage(
+    ::proto::Message_ContactMessage* contactmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactmessage_);
+  }
+  _impl_.contactmessage_ = contactmessage;
+  if (contactmessage) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactMessage)
+}
+inline ::proto::Message_ContactMessage* Message::release_contactmessage() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_ContactMessage* temp = _impl_.contactmessage_;
+  _impl_.contactmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ContactMessage* Message::unsafe_arena_release_contactmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.contactMessage)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Message_ContactMessage* temp = _impl_.contactmessage_;
+  _impl_.contactmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ContactMessage* Message::_internal_mutable_contactmessage() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.contactmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ContactMessage>(GetArenaForAllocation());
+    _impl_.contactmessage_ = p;
+  }
+  return _impl_.contactmessage_;
+}
+inline ::proto::Message_ContactMessage* Message::mutable_contactmessage() {
+  ::proto::Message_ContactMessage* _msg = _internal_mutable_contactmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.contactMessage)
+  return _msg;
+}
+inline void Message::set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contactmessage_;
+  }
+  if (contactmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactmessage);
+    if (message_arena != submessage_arena) {
+      contactmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contactmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.contactmessage_ = contactmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.contactMessage)
+}
+
+// optional .proto.Message.LocationMessage locationMessage = 5;
+inline bool Message::_internal_has_locationmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.locationmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_locationmessage() const {
+  return _internal_has_locationmessage();
+}
+inline void Message::clear_locationmessage() {
+  if (_impl_.locationmessage_ != nullptr) _impl_.locationmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Message_LocationMessage& Message::_internal_locationmessage() const {
+  const ::proto::Message_LocationMessage* p = _impl_.locationmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LocationMessage&>(
+      ::proto::_Message_LocationMessage_default_instance_);
+}
+inline const ::proto::Message_LocationMessage& Message::locationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.locationMessage)
+  return _internal_locationmessage();
+}
+inline void Message::unsafe_arena_set_allocated_locationmessage(
+    ::proto::Message_LocationMessage* locationmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locationmessage_);
+  }
+  _impl_.locationmessage_ = locationmessage;
+  if (locationmessage) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.locationMessage)
+}
+inline ::proto::Message_LocationMessage* Message::release_locationmessage() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_LocationMessage* temp = _impl_.locationmessage_;
+  _impl_.locationmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_LocationMessage* Message::unsafe_arena_release_locationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.locationMessage)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Message_LocationMessage* temp = _impl_.locationmessage_;
+  _impl_.locationmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_LocationMessage* Message::_internal_mutable_locationmessage() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.locationmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_LocationMessage>(GetArenaForAllocation());
+    _impl_.locationmessage_ = p;
+  }
+  return _impl_.locationmessage_;
+}
+inline ::proto::Message_LocationMessage* Message::mutable_locationmessage() {
+  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.locationMessage)
+  return _msg;
+}
+inline void Message::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.locationmessage_;
+  }
+  if (locationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage);
+    if (message_arena != submessage_arena) {
+      locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, locationmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.locationmessage_ = locationmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.locationMessage)
+}
+
+// optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
+inline bool Message::_internal_has_extendedtextmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.extendedtextmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_extendedtextmessage() const {
+  return _internal_has_extendedtextmessage();
+}
+inline void Message::clear_extendedtextmessage() {
+  if (_impl_.extendedtextmessage_ != nullptr) _impl_.extendedtextmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::Message_ExtendedTextMessage& Message::_internal_extendedtextmessage() const {
+  const ::proto::Message_ExtendedTextMessage* p = _impl_.extendedtextmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ExtendedTextMessage&>(
+      ::proto::_Message_ExtendedTextMessage_default_instance_);
+}
+inline const ::proto::Message_ExtendedTextMessage& Message::extendedtextmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.extendedTextMessage)
+  return _internal_extendedtextmessage();
+}
+inline void Message::unsafe_arena_set_allocated_extendedtextmessage(
+    ::proto::Message_ExtendedTextMessage* extendedtextmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extendedtextmessage_);
+  }
+  _impl_.extendedtextmessage_ = extendedtextmessage;
+  if (extendedtextmessage) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.extendedTextMessage)
+}
+inline ::proto::Message_ExtendedTextMessage* Message::release_extendedtextmessage() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_;
+  _impl_.extendedtextmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ExtendedTextMessage* Message::unsafe_arena_release_extendedtextmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.extendedTextMessage)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_;
+  _impl_.extendedtextmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ExtendedTextMessage* Message::_internal_mutable_extendedtextmessage() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.extendedtextmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(GetArenaForAllocation());
+    _impl_.extendedtextmessage_ = p;
+  }
+  return _impl_.extendedtextmessage_;
+}
+inline ::proto::Message_ExtendedTextMessage* Message::mutable_extendedtextmessage() {
+  ::proto::Message_ExtendedTextMessage* _msg = _internal_mutable_extendedtextmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.extendedTextMessage)
+  return _msg;
+}
+inline void Message::set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.extendedtextmessage_;
+  }
+  if (extendedtextmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extendedtextmessage);
+    if (message_arena != submessage_arena) {
+      extendedtextmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extendedtextmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.extendedtextmessage_ = extendedtextmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.extendedTextMessage)
+}
+
+// optional .proto.Message.DocumentMessage documentMessage = 7;
+inline bool Message::_internal_has_documentmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.documentmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_documentmessage() const {
+  return _internal_has_documentmessage();
+}
+inline void Message::clear_documentmessage() {
+  if (_impl_.documentmessage_ != nullptr) _impl_.documentmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::Message_DocumentMessage& Message::_internal_documentmessage() const {
+  const ::proto::Message_DocumentMessage* p = _impl_.documentmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DocumentMessage&>(
+      ::proto::_Message_DocumentMessage_default_instance_);
+}
+inline const ::proto::Message_DocumentMessage& Message::documentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.documentMessage)
+  return _internal_documentmessage();
+}
+inline void Message::unsafe_arena_set_allocated_documentmessage(
+    ::proto::Message_DocumentMessage* documentmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentmessage_);
+  }
+  _impl_.documentmessage_ = documentmessage;
+  if (documentmessage) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentMessage)
+}
+inline ::proto::Message_DocumentMessage* Message::release_documentmessage() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_;
+  _impl_.documentmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_DocumentMessage* Message::unsafe_arena_release_documentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.documentMessage)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_;
+  _impl_.documentmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_DocumentMessage* Message::_internal_mutable_documentmessage() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.documentmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_DocumentMessage>(GetArenaForAllocation());
+    _impl_.documentmessage_ = p;
+  }
+  return _impl_.documentmessage_;
+}
+inline ::proto::Message_DocumentMessage* Message::mutable_documentmessage() {
+  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.documentMessage)
+  return _msg;
+}
+inline void Message::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.documentmessage_;
+  }
+  if (documentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
+    if (message_arena != submessage_arena) {
+      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.documentmessage_ = documentmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.documentMessage)
+}
+
+// optional .proto.Message.AudioMessage audioMessage = 8;
+inline bool Message::_internal_has_audiomessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.audiomessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_audiomessage() const {
+  return _internal_has_audiomessage();
+}
+inline void Message::clear_audiomessage() {
+  if (_impl_.audiomessage_ != nullptr) _impl_.audiomessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::Message_AudioMessage& Message::_internal_audiomessage() const {
+  const ::proto::Message_AudioMessage* p = _impl_.audiomessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AudioMessage&>(
+      ::proto::_Message_AudioMessage_default_instance_);
+}
+inline const ::proto::Message_AudioMessage& Message::audiomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.audioMessage)
+  return _internal_audiomessage();
+}
+inline void Message::unsafe_arena_set_allocated_audiomessage(
+    ::proto::Message_AudioMessage* audiomessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audiomessage_);
+  }
+  _impl_.audiomessage_ = audiomessage;
+  if (audiomessage) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.audioMessage)
+}
+inline ::proto::Message_AudioMessage* Message::release_audiomessage() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_AudioMessage* temp = _impl_.audiomessage_;
+  _impl_.audiomessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_AudioMessage* Message::unsafe_arena_release_audiomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.audioMessage)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::Message_AudioMessage* temp = _impl_.audiomessage_;
+  _impl_.audiomessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_AudioMessage* Message::_internal_mutable_audiomessage() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.audiomessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_AudioMessage>(GetArenaForAllocation());
+    _impl_.audiomessage_ = p;
+  }
+  return _impl_.audiomessage_;
+}
+inline ::proto::Message_AudioMessage* Message::mutable_audiomessage() {
+  ::proto::Message_AudioMessage* _msg = _internal_mutable_audiomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.audioMessage)
+  return _msg;
+}
+inline void Message::set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.audiomessage_;
+  }
+  if (audiomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audiomessage);
+    if (message_arena != submessage_arena) {
+      audiomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, audiomessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.audiomessage_ = audiomessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.audioMessage)
+}
+
+// optional .proto.Message.VideoMessage videoMessage = 9;
+inline bool Message::_internal_has_videomessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.videomessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_videomessage() const {
+  return _internal_has_videomessage();
+}
+inline void Message::clear_videomessage() {
+  if (_impl_.videomessage_ != nullptr) _impl_.videomessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::Message_VideoMessage& Message::_internal_videomessage() const {
+  const ::proto::Message_VideoMessage* p = _impl_.videomessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_VideoMessage&>(
+      ::proto::_Message_VideoMessage_default_instance_);
+}
+inline const ::proto::Message_VideoMessage& Message::videomessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.videoMessage)
+  return _internal_videomessage();
+}
+inline void Message::unsafe_arena_set_allocated_videomessage(
+    ::proto::Message_VideoMessage* videomessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.videomessage_);
+  }
+  _impl_.videomessage_ = videomessage;
+  if (videomessage) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.videoMessage)
+}
+inline ::proto::Message_VideoMessage* Message::release_videomessage() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::Message_VideoMessage* temp = _impl_.videomessage_;
+  _impl_.videomessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_VideoMessage* Message::unsafe_arena_release_videomessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.videoMessage)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::Message_VideoMessage* temp = _impl_.videomessage_;
+  _impl_.videomessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_VideoMessage* Message::_internal_mutable_videomessage() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.videomessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_VideoMessage>(GetArenaForAllocation());
+    _impl_.videomessage_ = p;
+  }
+  return _impl_.videomessage_;
+}
+inline ::proto::Message_VideoMessage* Message::mutable_videomessage() {
+  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.videoMessage)
+  return _msg;
+}
+inline void Message::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.videomessage_;
+  }
+  if (videomessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
+    if (message_arena != submessage_arena) {
+      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, videomessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.videomessage_ = videomessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.videoMessage)
+}
+
+// optional .proto.Message.Call call = 10;
+inline bool Message::_internal_has_call() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.call_ != nullptr);
+  return value;
+}
+inline bool Message::has_call() const {
+  return _internal_has_call();
+}
+inline void Message::clear_call() {
+  if (_impl_.call_ != nullptr) _impl_.call_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const ::proto::Message_Call& Message::_internal_call() const {
+  const ::proto::Message_Call* p = _impl_.call_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_Call&>(
+      ::proto::_Message_Call_default_instance_);
+}
+inline const ::proto::Message_Call& Message::call() const {
+  // @@protoc_insertion_point(field_get:proto.Message.call)
+  return _internal_call();
+}
+inline void Message::unsafe_arena_set_allocated_call(
+    ::proto::Message_Call* call) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_);
+  }
+  _impl_.call_ = call;
+  if (call) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.call)
+}
+inline ::proto::Message_Call* Message::release_call() {
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::Message_Call* temp = _impl_.call_;
+  _impl_.call_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_Call* Message::unsafe_arena_release_call() {
+  // @@protoc_insertion_point(field_release:proto.Message.call)
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::Message_Call* temp = _impl_.call_;
+  _impl_.call_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_Call* Message::_internal_mutable_call() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  if (_impl_.call_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_Call>(GetArenaForAllocation());
+    _impl_.call_ = p;
+  }
+  return _impl_.call_;
+}
+inline ::proto::Message_Call* Message::mutable_call() {
+  ::proto::Message_Call* _msg = _internal_mutable_call();
+  // @@protoc_insertion_point(field_mutable:proto.Message.call)
+  return _msg;
+}
+inline void Message::set_allocated_call(::proto::Message_Call* call) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.call_;
+  }
+  if (call) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call);
+    if (message_arena != submessage_arena) {
+      call = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, call, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.call_ = call;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.call)
+}
+
+// optional .proto.Message.Chat chat = 11;
+inline bool Message::_internal_has_chat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.chat_ != nullptr);
+  return value;
+}
+inline bool Message::has_chat() const {
+  return _internal_has_chat();
+}
+inline void Message::clear_chat() {
+  if (_impl_.chat_ != nullptr) _impl_.chat_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const ::proto::Message_Chat& Message::_internal_chat() const {
+  const ::proto::Message_Chat* p = _impl_.chat_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_Chat&>(
+      ::proto::_Message_Chat_default_instance_);
+}
+inline const ::proto::Message_Chat& Message::chat() const {
+  // @@protoc_insertion_point(field_get:proto.Message.chat)
+  return _internal_chat();
+}
+inline void Message::unsafe_arena_set_allocated_chat(
+    ::proto::Message_Chat* chat) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chat_);
+  }
+  _impl_.chat_ = chat;
+  if (chat) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.chat)
+}
+inline ::proto::Message_Chat* Message::release_chat() {
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::Message_Chat* temp = _impl_.chat_;
+  _impl_.chat_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_Chat* Message::unsafe_arena_release_chat() {
+  // @@protoc_insertion_point(field_release:proto.Message.chat)
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::Message_Chat* temp = _impl_.chat_;
+  _impl_.chat_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_Chat* Message::_internal_mutable_chat() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  if (_impl_.chat_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_Chat>(GetArenaForAllocation());
+    _impl_.chat_ = p;
+  }
+  return _impl_.chat_;
+}
+inline ::proto::Message_Chat* Message::mutable_chat() {
+  ::proto::Message_Chat* _msg = _internal_mutable_chat();
+  // @@protoc_insertion_point(field_mutable:proto.Message.chat)
+  return _msg;
+}
+inline void Message::set_allocated_chat(::proto::Message_Chat* chat) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.chat_;
+  }
+  if (chat) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chat);
+    if (message_arena != submessage_arena) {
+      chat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, chat, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.chat_ = chat;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.chat)
+}
+
+// optional .proto.Message.ProtocolMessage protocolMessage = 12;
+inline bool Message::_internal_has_protocolmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.protocolmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_protocolmessage() const {
+  return _internal_has_protocolmessage();
+}
+inline void Message::clear_protocolmessage() {
+  if (_impl_.protocolmessage_ != nullptr) _impl_.protocolmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const ::proto::Message_ProtocolMessage& Message::_internal_protocolmessage() const {
+  const ::proto::Message_ProtocolMessage* p = _impl_.protocolmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProtocolMessage&>(
+      ::proto::_Message_ProtocolMessage_default_instance_);
+}
+inline const ::proto::Message_ProtocolMessage& Message::protocolmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.protocolMessage)
+  return _internal_protocolmessage();
+}
+inline void Message::unsafe_arena_set_allocated_protocolmessage(
+    ::proto::Message_ProtocolMessage* protocolmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.protocolmessage_);
+  }
+  _impl_.protocolmessage_ = protocolmessage;
+  if (protocolmessage) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.protocolMessage)
+}
+inline ::proto::Message_ProtocolMessage* Message::release_protocolmessage() {
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_;
+  _impl_.protocolmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ProtocolMessage* Message::unsafe_arena_release_protocolmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.protocolMessage)
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_;
+  _impl_.protocolmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ProtocolMessage* Message::_internal_mutable_protocolmessage() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  if (_impl_.protocolmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ProtocolMessage>(GetArenaForAllocation());
+    _impl_.protocolmessage_ = p;
+  }
+  return _impl_.protocolmessage_;
+}
+inline ::proto::Message_ProtocolMessage* Message::mutable_protocolmessage() {
+  ::proto::Message_ProtocolMessage* _msg = _internal_mutable_protocolmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.protocolMessage)
+  return _msg;
+}
+inline void Message::set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.protocolmessage_;
+  }
+  if (protocolmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(protocolmessage);
+    if (message_arena != submessage_arena) {
+      protocolmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, protocolmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.protocolmessage_ = protocolmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.protocolMessage)
+}
+
+// optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
+inline bool Message::_internal_has_contactsarraymessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contactsarraymessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_contactsarraymessage() const {
+  return _internal_has_contactsarraymessage();
+}
+inline void Message::clear_contactsarraymessage() {
+  if (_impl_.contactsarraymessage_ != nullptr) _impl_.contactsarraymessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::Message_ContactsArrayMessage& Message::_internal_contactsarraymessage() const {
+  const ::proto::Message_ContactsArrayMessage* p = _impl_.contactsarraymessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ContactsArrayMessage&>(
+      ::proto::_Message_ContactsArrayMessage_default_instance_);
+}
+inline const ::proto::Message_ContactsArrayMessage& Message::contactsarraymessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.contactsArrayMessage)
+  return _internal_contactsarraymessage();
+}
+inline void Message::unsafe_arena_set_allocated_contactsarraymessage(
+    ::proto::Message_ContactsArrayMessage* contactsarraymessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactsarraymessage_);
+  }
+  _impl_.contactsarraymessage_ = contactsarraymessage;
+  if (contactsarraymessage) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactsArrayMessage)
+}
+inline ::proto::Message_ContactsArrayMessage* Message::release_contactsarraymessage() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_;
+  _impl_.contactsarraymessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ContactsArrayMessage* Message::unsafe_arena_release_contactsarraymessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.contactsArrayMessage)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_;
+  _impl_.contactsarraymessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ContactsArrayMessage* Message::_internal_mutable_contactsarraymessage() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.contactsarraymessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(GetArenaForAllocation());
+    _impl_.contactsarraymessage_ = p;
+  }
+  return _impl_.contactsarraymessage_;
+}
+inline ::proto::Message_ContactsArrayMessage* Message::mutable_contactsarraymessage() {
+  ::proto::Message_ContactsArrayMessage* _msg = _internal_mutable_contactsarraymessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.contactsArrayMessage)
+  return _msg;
+}
+inline void Message::set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contactsarraymessage_;
+  }
+  if (contactsarraymessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactsarraymessage);
+    if (message_arena != submessage_arena) {
+      contactsarraymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contactsarraymessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.contactsarraymessage_ = contactsarraymessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.contactsArrayMessage)
+}
+
+// optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
+inline bool Message::_internal_has_highlystructuredmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.highlystructuredmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_highlystructuredmessage() const {
+  return _internal_has_highlystructuredmessage();
+}
+inline void Message::clear_highlystructuredmessage() {
+  if (_impl_.highlystructuredmessage_ != nullptr) _impl_.highlystructuredmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message::_internal_highlystructuredmessage() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.highlystructuredmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& Message::highlystructuredmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.highlyStructuredMessage)
+  return _internal_highlystructuredmessage();
+}
+inline void Message::unsafe_arena_set_allocated_highlystructuredmessage(
+    ::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.highlystructuredmessage_);
+  }
+  _impl_.highlystructuredmessage_ = highlystructuredmessage;
+  if (highlystructuredmessage) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.highlyStructuredMessage)
+}
+inline ::proto::Message_HighlyStructuredMessage* Message::release_highlystructuredmessage() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_;
+  _impl_.highlystructuredmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message::unsafe_arena_release_highlystructuredmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.highlyStructuredMessage)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_;
+  _impl_.highlystructuredmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message::_internal_mutable_highlystructuredmessage() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.highlystructuredmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.highlystructuredmessage_ = p;
+  }
+  return _impl_.highlystructuredmessage_;
+}
+inline ::proto::Message_HighlyStructuredMessage* Message::mutable_highlystructuredmessage() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.highlyStructuredMessage)
+  return _msg;
+}
+inline void Message::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.highlystructuredmessage_;
+  }
+  if (highlystructuredmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage);
+    if (message_arena != submessage_arena) {
+      highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, highlystructuredmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.highlystructuredmessage_ = highlystructuredmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.highlyStructuredMessage)
+}
+
+// optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+inline bool Message::_internal_has_fastratchetkeysenderkeydistributionmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_fastratchetkeysenderkeydistributionmessage() const {
+  return _internal_has_fastratchetkeysenderkeydistributionmessage();
+}
+inline void Message::clear_fastratchetkeysenderkeydistributionmessage() {
+  if (_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr) _impl_.fastratchetkeysenderkeydistributionmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_fastratchetkeysenderkeydistributionmessage() const {
+  const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.fastratchetkeysenderkeydistributionmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SenderKeyDistributionMessage&>(
+      ::proto::_Message_SenderKeyDistributionMessage_default_instance_);
+}
+inline const ::proto::Message_SenderKeyDistributionMessage& Message::fastratchetkeysenderkeydistributionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
+  return _internal_fastratchetkeysenderkeydistributionmessage();
+}
+inline void Message::unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage(
+    ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fastratchetkeysenderkeydistributionmessage_);
+  }
+  _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage;
+  if (fastratchetkeysenderkeydistributionmessage) {
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::release_fastratchetkeysenderkeydistributionmessage() {
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_;
+  _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_fastratchetkeysenderkeydistributionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_;
+  _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_fastratchetkeysenderkeydistributionmessage() {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  if (_impl_.fastratchetkeysenderkeydistributionmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation());
+    _impl_.fastratchetkeysenderkeydistributionmessage_ = p;
+  }
+  return _impl_.fastratchetkeysenderkeydistributionmessage_;
+}
+inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_fastratchetkeysenderkeydistributionmessage() {
+  ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_fastratchetkeysenderkeydistributionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
+  return _msg;
+}
+inline void Message::set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.fastratchetkeysenderkeydistributionmessage_;
+  }
+  if (fastratchetkeysenderkeydistributionmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fastratchetkeysenderkeydistributionmessage);
+    if (message_arena != submessage_arena) {
+      fastratchetkeysenderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fastratchetkeysenderkeydistributionmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
+}
+
+// optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
+inline bool Message::_internal_has_sendpaymentmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.sendpaymentmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_sendpaymentmessage() const {
+  return _internal_has_sendpaymentmessage();
+}
+inline void Message::clear_sendpaymentmessage() {
+  if (_impl_.sendpaymentmessage_ != nullptr) _impl_.sendpaymentmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline const ::proto::Message_SendPaymentMessage& Message::_internal_sendpaymentmessage() const {
+  const ::proto::Message_SendPaymentMessage* p = _impl_.sendpaymentmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SendPaymentMessage&>(
+      ::proto::_Message_SendPaymentMessage_default_instance_);
+}
+inline const ::proto::Message_SendPaymentMessage& Message::sendpaymentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.sendPaymentMessage)
+  return _internal_sendpaymentmessage();
+}
+inline void Message::unsafe_arena_set_allocated_sendpaymentmessage(
+    ::proto::Message_SendPaymentMessage* sendpaymentmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendpaymentmessage_);
+  }
+  _impl_.sendpaymentmessage_ = sendpaymentmessage;
+  if (sendpaymentmessage) {
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.sendPaymentMessage)
+}
+inline ::proto::Message_SendPaymentMessage* Message::release_sendpaymentmessage() {
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_;
+  _impl_.sendpaymentmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_SendPaymentMessage* Message::unsafe_arena_release_sendpaymentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.sendPaymentMessage)
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_;
+  _impl_.sendpaymentmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_SendPaymentMessage* Message::_internal_mutable_sendpaymentmessage() {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  if (_impl_.sendpaymentmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_SendPaymentMessage>(GetArenaForAllocation());
+    _impl_.sendpaymentmessage_ = p;
+  }
+  return _impl_.sendpaymentmessage_;
+}
+inline ::proto::Message_SendPaymentMessage* Message::mutable_sendpaymentmessage() {
+  ::proto::Message_SendPaymentMessage* _msg = _internal_mutable_sendpaymentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.sendPaymentMessage)
+  return _msg;
+}
+inline void Message::set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.sendpaymentmessage_;
+  }
+  if (sendpaymentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendpaymentmessage);
+    if (message_arena != submessage_arena) {
+      sendpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, sendpaymentmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  _impl_.sendpaymentmessage_ = sendpaymentmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.sendPaymentMessage)
+}
+
+// optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
+inline bool Message::_internal_has_livelocationmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.livelocationmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_livelocationmessage() const {
+  return _internal_has_livelocationmessage();
+}
+inline void Message::clear_livelocationmessage() {
+  if (_impl_.livelocationmessage_ != nullptr) _impl_.livelocationmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline const ::proto::Message_LiveLocationMessage& Message::_internal_livelocationmessage() const {
+  const ::proto::Message_LiveLocationMessage* p = _impl_.livelocationmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LiveLocationMessage&>(
+      ::proto::_Message_LiveLocationMessage_default_instance_);
+}
+inline const ::proto::Message_LiveLocationMessage& Message::livelocationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.liveLocationMessage)
+  return _internal_livelocationmessage();
+}
+inline void Message::unsafe_arena_set_allocated_livelocationmessage(
+    ::proto::Message_LiveLocationMessage* livelocationmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.livelocationmessage_);
+  }
+  _impl_.livelocationmessage_ = livelocationmessage;
+  if (livelocationmessage) {
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.liveLocationMessage)
+}
+inline ::proto::Message_LiveLocationMessage* Message::release_livelocationmessage() {
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_;
+  _impl_.livelocationmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_LiveLocationMessage* Message::unsafe_arena_release_livelocationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.liveLocationMessage)
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_;
+  _impl_.livelocationmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_LiveLocationMessage* Message::_internal_mutable_livelocationmessage() {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  if (_impl_.livelocationmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation());
+    _impl_.livelocationmessage_ = p;
+  }
+  return _impl_.livelocationmessage_;
+}
+inline ::proto::Message_LiveLocationMessage* Message::mutable_livelocationmessage() {
+  ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_livelocationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.liveLocationMessage)
+  return _msg;
+}
+inline void Message::set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.livelocationmessage_;
+  }
+  if (livelocationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(livelocationmessage);
+    if (message_arena != submessage_arena) {
+      livelocationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, livelocationmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  _impl_.livelocationmessage_ = livelocationmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.liveLocationMessage)
+}
+
+// optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
+inline bool Message::_internal_has_requestpaymentmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestpaymentmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_requestpaymentmessage() const {
+  return _internal_has_requestpaymentmessage();
+}
+inline void Message::clear_requestpaymentmessage() {
+  if (_impl_.requestpaymentmessage_ != nullptr) _impl_.requestpaymentmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline const ::proto::Message_RequestPaymentMessage& Message::_internal_requestpaymentmessage() const {
+  const ::proto::Message_RequestPaymentMessage* p = _impl_.requestpaymentmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestPaymentMessage&>(
+      ::proto::_Message_RequestPaymentMessage_default_instance_);
+}
+inline const ::proto::Message_RequestPaymentMessage& Message::requestpaymentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.requestPaymentMessage)
+  return _internal_requestpaymentmessage();
+}
+inline void Message::unsafe_arena_set_allocated_requestpaymentmessage(
+    ::proto::Message_RequestPaymentMessage* requestpaymentmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestpaymentmessage_);
+  }
+  _impl_.requestpaymentmessage_ = requestpaymentmessage;
+  if (requestpaymentmessage) {
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPaymentMessage)
+}
+inline ::proto::Message_RequestPaymentMessage* Message::release_requestpaymentmessage() {
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_;
+  _impl_.requestpaymentmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_RequestPaymentMessage* Message::unsafe_arena_release_requestpaymentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.requestPaymentMessage)
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_;
+  _impl_.requestpaymentmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_RequestPaymentMessage* Message::_internal_mutable_requestpaymentmessage() {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  if (_impl_.requestpaymentmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(GetArenaForAllocation());
+    _impl_.requestpaymentmessage_ = p;
+  }
+  return _impl_.requestpaymentmessage_;
+}
+inline ::proto::Message_RequestPaymentMessage* Message::mutable_requestpaymentmessage() {
+  ::proto::Message_RequestPaymentMessage* _msg = _internal_mutable_requestpaymentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.requestPaymentMessage)
+  return _msg;
+}
+inline void Message::set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestpaymentmessage_;
+  }
+  if (requestpaymentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestpaymentmessage);
+    if (message_arena != submessage_arena) {
+      requestpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestpaymentmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  _impl_.requestpaymentmessage_ = requestpaymentmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPaymentMessage)
+}
+
+// optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+inline bool Message::_internal_has_declinepaymentrequestmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.declinepaymentrequestmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_declinepaymentrequestmessage() const {
+  return _internal_has_declinepaymentrequestmessage();
+}
+inline void Message::clear_declinepaymentrequestmessage() {
+  if (_impl_.declinepaymentrequestmessage_ != nullptr) _impl_.declinepaymentrequestmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline const ::proto::Message_DeclinePaymentRequestMessage& Message::_internal_declinepaymentrequestmessage() const {
+  const ::proto::Message_DeclinePaymentRequestMessage* p = _impl_.declinepaymentrequestmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DeclinePaymentRequestMessage&>(
+      ::proto::_Message_DeclinePaymentRequestMessage_default_instance_);
+}
+inline const ::proto::Message_DeclinePaymentRequestMessage& Message::declinepaymentrequestmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.declinePaymentRequestMessage)
+  return _internal_declinepaymentrequestmessage();
+}
+inline void Message::unsafe_arena_set_allocated_declinepaymentrequestmessage(
+    ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.declinepaymentrequestmessage_);
+  }
+  _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage;
+  if (declinepaymentrequestmessage) {
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.declinePaymentRequestMessage)
+}
+inline ::proto::Message_DeclinePaymentRequestMessage* Message::release_declinepaymentrequestmessage() {
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_;
+  _impl_.declinepaymentrequestmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_DeclinePaymentRequestMessage* Message::unsafe_arena_release_declinepaymentrequestmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.declinePaymentRequestMessage)
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_;
+  _impl_.declinepaymentrequestmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_DeclinePaymentRequestMessage* Message::_internal_mutable_declinepaymentrequestmessage() {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  if (_impl_.declinepaymentrequestmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(GetArenaForAllocation());
+    _impl_.declinepaymentrequestmessage_ = p;
+  }
+  return _impl_.declinepaymentrequestmessage_;
+}
+inline ::proto::Message_DeclinePaymentRequestMessage* Message::mutable_declinepaymentrequestmessage() {
+  ::proto::Message_DeclinePaymentRequestMessage* _msg = _internal_mutable_declinepaymentrequestmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.declinePaymentRequestMessage)
+  return _msg;
+}
+inline void Message::set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.declinepaymentrequestmessage_;
+  }
+  if (declinepaymentrequestmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(declinepaymentrequestmessage);
+    if (message_arena != submessage_arena) {
+      declinepaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, declinepaymentrequestmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.declinePaymentRequestMessage)
+}
+
+// optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+inline bool Message::_internal_has_cancelpaymentrequestmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.cancelpaymentrequestmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_cancelpaymentrequestmessage() const {
+  return _internal_has_cancelpaymentrequestmessage();
+}
+inline void Message::clear_cancelpaymentrequestmessage() {
+  if (_impl_.cancelpaymentrequestmessage_ != nullptr) _impl_.cancelpaymentrequestmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline const ::proto::Message_CancelPaymentRequestMessage& Message::_internal_cancelpaymentrequestmessage() const {
+  const ::proto::Message_CancelPaymentRequestMessage* p = _impl_.cancelpaymentrequestmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_CancelPaymentRequestMessage&>(
+      ::proto::_Message_CancelPaymentRequestMessage_default_instance_);
+}
+inline const ::proto::Message_CancelPaymentRequestMessage& Message::cancelpaymentrequestmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.cancelPaymentRequestMessage)
+  return _internal_cancelpaymentrequestmessage();
+}
+inline void Message::unsafe_arena_set_allocated_cancelpaymentrequestmessage(
+    ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cancelpaymentrequestmessage_);
+  }
+  _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage;
+  if (cancelpaymentrequestmessage) {
+    _impl_._has_bits_[0] |= 0x00080000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00080000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.cancelPaymentRequestMessage)
+}
+inline ::proto::Message_CancelPaymentRequestMessage* Message::release_cancelpaymentrequestmessage() {
+  _impl_._has_bits_[0] &= ~0x00080000u;
+  ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_;
+  _impl_.cancelpaymentrequestmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_CancelPaymentRequestMessage* Message::unsafe_arena_release_cancelpaymentrequestmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.cancelPaymentRequestMessage)
+  _impl_._has_bits_[0] &= ~0x00080000u;
+  ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_;
+  _impl_.cancelpaymentrequestmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_CancelPaymentRequestMessage* Message::_internal_mutable_cancelpaymentrequestmessage() {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  if (_impl_.cancelpaymentrequestmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(GetArenaForAllocation());
+    _impl_.cancelpaymentrequestmessage_ = p;
+  }
+  return _impl_.cancelpaymentrequestmessage_;
+}
+inline ::proto::Message_CancelPaymentRequestMessage* Message::mutable_cancelpaymentrequestmessage() {
+  ::proto::Message_CancelPaymentRequestMessage* _msg = _internal_mutable_cancelpaymentrequestmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.cancelPaymentRequestMessage)
+  return _msg;
+}
+inline void Message::set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.cancelpaymentrequestmessage_;
+  }
+  if (cancelpaymentrequestmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cancelpaymentrequestmessage);
+    if (message_arena != submessage_arena) {
+      cancelpaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cancelpaymentrequestmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00080000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00080000u;
+  }
+  _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.cancelPaymentRequestMessage)
+}
+
+// optional .proto.Message.TemplateMessage templateMessage = 25;
+inline bool Message::_internal_has_templatemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.templatemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_templatemessage() const {
+  return _internal_has_templatemessage();
+}
+inline void Message::clear_templatemessage() {
+  if (_impl_.templatemessage_ != nullptr) _impl_.templatemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline const ::proto::Message_TemplateMessage& Message::_internal_templatemessage() const {
+  const ::proto::Message_TemplateMessage* p = _impl_.templatemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage&>(
+      ::proto::_Message_TemplateMessage_default_instance_);
+}
+inline const ::proto::Message_TemplateMessage& Message::templatemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.templateMessage)
+  return _internal_templatemessage();
+}
+inline void Message::unsafe_arena_set_allocated_templatemessage(
+    ::proto::Message_TemplateMessage* templatemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatemessage_);
+  }
+  _impl_.templatemessage_ = templatemessage;
+  if (templatemessage) {
+    _impl_._has_bits_[0] |= 0x00100000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00100000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateMessage)
+}
+inline ::proto::Message_TemplateMessage* Message::release_templatemessage() {
+  _impl_._has_bits_[0] &= ~0x00100000u;
+  ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_;
+  _impl_.templatemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_TemplateMessage* Message::unsafe_arena_release_templatemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.templateMessage)
+  _impl_._has_bits_[0] &= ~0x00100000u;
+  ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_;
+  _impl_.templatemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_TemplateMessage* Message::_internal_mutable_templatemessage() {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  if (_impl_.templatemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation());
+    _impl_.templatemessage_ = p;
+  }
+  return _impl_.templatemessage_;
+}
+inline ::proto::Message_TemplateMessage* Message::mutable_templatemessage() {
+  ::proto::Message_TemplateMessage* _msg = _internal_mutable_templatemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.templateMessage)
+  return _msg;
+}
+inline void Message::set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.templatemessage_;
+  }
+  if (templatemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatemessage);
+    if (message_arena != submessage_arena) {
+      templatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, templatemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00100000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00100000u;
+  }
+  _impl_.templatemessage_ = templatemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.templateMessage)
+}
+
+// optional .proto.Message.StickerMessage stickerMessage = 26;
+inline bool Message::_internal_has_stickermessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_stickermessage() const {
+  return _internal_has_stickermessage();
+}
+inline void Message::clear_stickermessage() {
+  if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline const ::proto::Message_StickerMessage& Message::_internal_stickermessage() const {
+  const ::proto::Message_StickerMessage* p = _impl_.stickermessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerMessage&>(
+      ::proto::_Message_StickerMessage_default_instance_);
+}
+inline const ::proto::Message_StickerMessage& Message::stickermessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.stickerMessage)
+  return _internal_stickermessage();
+}
+inline void Message::unsafe_arena_set_allocated_stickermessage(
+    ::proto::Message_StickerMessage* stickermessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_);
+  }
+  _impl_.stickermessage_ = stickermessage;
+  if (stickermessage) {
+    _impl_._has_bits_[0] |= 0x00200000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00200000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerMessage)
+}
+inline ::proto::Message_StickerMessage* Message::release_stickermessage() {
+  _impl_._has_bits_[0] &= ~0x00200000u;
+  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
+  _impl_.stickermessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_StickerMessage* Message::unsafe_arena_release_stickermessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.stickerMessage)
+  _impl_._has_bits_[0] &= ~0x00200000u;
+  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
+  _impl_.stickermessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_StickerMessage* Message::_internal_mutable_stickermessage() {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  if (_impl_.stickermessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation());
+    _impl_.stickermessage_ = p;
+  }
+  return _impl_.stickermessage_;
+}
+inline ::proto::Message_StickerMessage* Message::mutable_stickermessage() {
+  ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.stickerMessage)
+  return _msg;
+}
+inline void Message::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.stickermessage_;
+  }
+  if (stickermessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage);
+    if (message_arena != submessage_arena) {
+      stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, stickermessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00200000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00200000u;
+  }
+  _impl_.stickermessage_ = stickermessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerMessage)
+}
+
+// optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
+inline bool Message::_internal_has_groupinvitemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.groupinvitemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_groupinvitemessage() const {
+  return _internal_has_groupinvitemessage();
+}
+inline void Message::clear_groupinvitemessage() {
+  if (_impl_.groupinvitemessage_ != nullptr) _impl_.groupinvitemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline const ::proto::Message_GroupInviteMessage& Message::_internal_groupinvitemessage() const {
+  const ::proto::Message_GroupInviteMessage* p = _impl_.groupinvitemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_GroupInviteMessage&>(
+      ::proto::_Message_GroupInviteMessage_default_instance_);
+}
+inline const ::proto::Message_GroupInviteMessage& Message::groupinvitemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.groupInviteMessage)
+  return _internal_groupinvitemessage();
+}
+inline void Message::unsafe_arena_set_allocated_groupinvitemessage(
+    ::proto::Message_GroupInviteMessage* groupinvitemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.groupinvitemessage_);
+  }
+  _impl_.groupinvitemessage_ = groupinvitemessage;
+  if (groupinvitemessage) {
+    _impl_._has_bits_[0] |= 0x00400000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00400000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.groupInviteMessage)
+}
+inline ::proto::Message_GroupInviteMessage* Message::release_groupinvitemessage() {
+  _impl_._has_bits_[0] &= ~0x00400000u;
+  ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_;
+  _impl_.groupinvitemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_GroupInviteMessage* Message::unsafe_arena_release_groupinvitemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.groupInviteMessage)
+  _impl_._has_bits_[0] &= ~0x00400000u;
+  ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_;
+  _impl_.groupinvitemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_GroupInviteMessage* Message::_internal_mutable_groupinvitemessage() {
+  _impl_._has_bits_[0] |= 0x00400000u;
+  if (_impl_.groupinvitemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_GroupInviteMessage>(GetArenaForAllocation());
+    _impl_.groupinvitemessage_ = p;
+  }
+  return _impl_.groupinvitemessage_;
+}
+inline ::proto::Message_GroupInviteMessage* Message::mutable_groupinvitemessage() {
+  ::proto::Message_GroupInviteMessage* _msg = _internal_mutable_groupinvitemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.groupInviteMessage)
+  return _msg;
+}
+inline void Message::set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.groupinvitemessage_;
+  }
+  if (groupinvitemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(groupinvitemessage);
+    if (message_arena != submessage_arena) {
+      groupinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, groupinvitemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00400000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00400000u;
+  }
+  _impl_.groupinvitemessage_ = groupinvitemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.groupInviteMessage)
+}
+
+// optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+inline bool Message::_internal_has_templatebuttonreplymessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.templatebuttonreplymessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_templatebuttonreplymessage() const {
+  return _internal_has_templatebuttonreplymessage();
+}
+inline void Message::clear_templatebuttonreplymessage() {
+  if (_impl_.templatebuttonreplymessage_ != nullptr) _impl_.templatebuttonreplymessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline const ::proto::Message_TemplateButtonReplyMessage& Message::_internal_templatebuttonreplymessage() const {
+  const ::proto::Message_TemplateButtonReplyMessage* p = _impl_.templatebuttonreplymessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateButtonReplyMessage&>(
+      ::proto::_Message_TemplateButtonReplyMessage_default_instance_);
+}
+inline const ::proto::Message_TemplateButtonReplyMessage& Message::templatebuttonreplymessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.templateButtonReplyMessage)
+  return _internal_templatebuttonreplymessage();
+}
+inline void Message::unsafe_arena_set_allocated_templatebuttonreplymessage(
+    ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatebuttonreplymessage_);
+  }
+  _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage;
+  if (templatebuttonreplymessage) {
+    _impl_._has_bits_[0] |= 0x00800000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00800000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateButtonReplyMessage)
+}
+inline ::proto::Message_TemplateButtonReplyMessage* Message::release_templatebuttonreplymessage() {
+  _impl_._has_bits_[0] &= ~0x00800000u;
+  ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_;
+  _impl_.templatebuttonreplymessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_TemplateButtonReplyMessage* Message::unsafe_arena_release_templatebuttonreplymessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.templateButtonReplyMessage)
+  _impl_._has_bits_[0] &= ~0x00800000u;
+  ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_;
+  _impl_.templatebuttonreplymessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_TemplateButtonReplyMessage* Message::_internal_mutable_templatebuttonreplymessage() {
+  _impl_._has_bits_[0] |= 0x00800000u;
+  if (_impl_.templatebuttonreplymessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(GetArenaForAllocation());
+    _impl_.templatebuttonreplymessage_ = p;
+  }
+  return _impl_.templatebuttonreplymessage_;
+}
+inline ::proto::Message_TemplateButtonReplyMessage* Message::mutable_templatebuttonreplymessage() {
+  ::proto::Message_TemplateButtonReplyMessage* _msg = _internal_mutable_templatebuttonreplymessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.templateButtonReplyMessage)
+  return _msg;
+}
+inline void Message::set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.templatebuttonreplymessage_;
+  }
+  if (templatebuttonreplymessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatebuttonreplymessage);
+    if (message_arena != submessage_arena) {
+      templatebuttonreplymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, templatebuttonreplymessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00800000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00800000u;
+  }
+  _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.templateButtonReplyMessage)
+}
+
+// optional .proto.Message.ProductMessage productMessage = 30;
+inline bool Message::_internal_has_productmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.productmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_productmessage() const {
+  return _internal_has_productmessage();
+}
+inline void Message::clear_productmessage() {
+  if (_impl_.productmessage_ != nullptr) _impl_.productmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x01000000u;
+}
+inline const ::proto::Message_ProductMessage& Message::_internal_productmessage() const {
+  const ::proto::Message_ProductMessage* p = _impl_.productmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage&>(
+      ::proto::_Message_ProductMessage_default_instance_);
+}
+inline const ::proto::Message_ProductMessage& Message::productmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.productMessage)
+  return _internal_productmessage();
+}
+inline void Message::unsafe_arena_set_allocated_productmessage(
+    ::proto::Message_ProductMessage* productmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productmessage_);
+  }
+  _impl_.productmessage_ = productmessage;
+  if (productmessage) {
+    _impl_._has_bits_[0] |= 0x01000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x01000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.productMessage)
+}
+inline ::proto::Message_ProductMessage* Message::release_productmessage() {
+  _impl_._has_bits_[0] &= ~0x01000000u;
+  ::proto::Message_ProductMessage* temp = _impl_.productmessage_;
+  _impl_.productmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ProductMessage* Message::unsafe_arena_release_productmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.productMessage)
+  _impl_._has_bits_[0] &= ~0x01000000u;
+  ::proto::Message_ProductMessage* temp = _impl_.productmessage_;
+  _impl_.productmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ProductMessage* Message::_internal_mutable_productmessage() {
+  _impl_._has_bits_[0] |= 0x01000000u;
+  if (_impl_.productmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage>(GetArenaForAllocation());
+    _impl_.productmessage_ = p;
+  }
+  return _impl_.productmessage_;
+}
+inline ::proto::Message_ProductMessage* Message::mutable_productmessage() {
+  ::proto::Message_ProductMessage* _msg = _internal_mutable_productmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.productMessage)
+  return _msg;
+}
+inline void Message::set_allocated_productmessage(::proto::Message_ProductMessage* productmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.productmessage_;
+  }
+  if (productmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productmessage);
+    if (message_arena != submessage_arena) {
+      productmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, productmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x01000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x01000000u;
+  }
+  _impl_.productmessage_ = productmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.productMessage)
+}
+
+// optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
+inline bool Message::_internal_has_devicesentmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.devicesentmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_devicesentmessage() const {
+  return _internal_has_devicesentmessage();
+}
+inline void Message::clear_devicesentmessage() {
+  if (_impl_.devicesentmessage_ != nullptr) _impl_.devicesentmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x02000000u;
+}
+inline const ::proto::Message_DeviceSentMessage& Message::_internal_devicesentmessage() const {
+  const ::proto::Message_DeviceSentMessage* p = _impl_.devicesentmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DeviceSentMessage&>(
+      ::proto::_Message_DeviceSentMessage_default_instance_);
+}
+inline const ::proto::Message_DeviceSentMessage& Message::devicesentmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.deviceSentMessage)
+  return _internal_devicesentmessage();
+}
+inline void Message::unsafe_arena_set_allocated_devicesentmessage(
+    ::proto::Message_DeviceSentMessage* devicesentmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicesentmessage_);
+  }
+  _impl_.devicesentmessage_ = devicesentmessage;
+  if (devicesentmessage) {
+    _impl_._has_bits_[0] |= 0x02000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x02000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.deviceSentMessage)
+}
+inline ::proto::Message_DeviceSentMessage* Message::release_devicesentmessage() {
+  _impl_._has_bits_[0] &= ~0x02000000u;
+  ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_;
+  _impl_.devicesentmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_DeviceSentMessage* Message::unsafe_arena_release_devicesentmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.deviceSentMessage)
+  _impl_._has_bits_[0] &= ~0x02000000u;
+  ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_;
+  _impl_.devicesentmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_DeviceSentMessage* Message::_internal_mutable_devicesentmessage() {
+  _impl_._has_bits_[0] |= 0x02000000u;
+  if (_impl_.devicesentmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_DeviceSentMessage>(GetArenaForAllocation());
+    _impl_.devicesentmessage_ = p;
+  }
+  return _impl_.devicesentmessage_;
+}
+inline ::proto::Message_DeviceSentMessage* Message::mutable_devicesentmessage() {
+  ::proto::Message_DeviceSentMessage* _msg = _internal_mutable_devicesentmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.deviceSentMessage)
+  return _msg;
+}
+inline void Message::set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.devicesentmessage_;
+  }
+  if (devicesentmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicesentmessage);
+    if (message_arena != submessage_arena) {
+      devicesentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, devicesentmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x02000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x02000000u;
+  }
+  _impl_.devicesentmessage_ = devicesentmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.deviceSentMessage)
+}
+
+// optional .proto.MessageContextInfo messageContextInfo = 35;
+inline bool Message::_internal_has_messagecontextinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.messagecontextinfo_ != nullptr);
+  return value;
+}
+inline bool Message::has_messagecontextinfo() const {
+  return _internal_has_messagecontextinfo();
+}
+inline void Message::clear_messagecontextinfo() {
+  if (_impl_.messagecontextinfo_ != nullptr) _impl_.messagecontextinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x04000000u;
+}
+inline const ::proto::MessageContextInfo& Message::_internal_messagecontextinfo() const {
+  const ::proto::MessageContextInfo* p = _impl_.messagecontextinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageContextInfo&>(
+      ::proto::_MessageContextInfo_default_instance_);
+}
+inline const ::proto::MessageContextInfo& Message::messagecontextinfo() const {
+  // @@protoc_insertion_point(field_get:proto.Message.messageContextInfo)
+  return _internal_messagecontextinfo();
+}
+inline void Message::unsafe_arena_set_allocated_messagecontextinfo(
+    ::proto::MessageContextInfo* messagecontextinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagecontextinfo_);
+  }
+  _impl_.messagecontextinfo_ = messagecontextinfo;
+  if (messagecontextinfo) {
+    _impl_._has_bits_[0] |= 0x04000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x04000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.messageContextInfo)
+}
+inline ::proto::MessageContextInfo* Message::release_messagecontextinfo() {
+  _impl_._has_bits_[0] &= ~0x04000000u;
+  ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_;
+  _impl_.messagecontextinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageContextInfo* Message::unsafe_arena_release_messagecontextinfo() {
+  // @@protoc_insertion_point(field_release:proto.Message.messageContextInfo)
+  _impl_._has_bits_[0] &= ~0x04000000u;
+  ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_;
+  _impl_.messagecontextinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageContextInfo* Message::_internal_mutable_messagecontextinfo() {
+  _impl_._has_bits_[0] |= 0x04000000u;
+  if (_impl_.messagecontextinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageContextInfo>(GetArenaForAllocation());
+    _impl_.messagecontextinfo_ = p;
+  }
+  return _impl_.messagecontextinfo_;
+}
+inline ::proto::MessageContextInfo* Message::mutable_messagecontextinfo() {
+  ::proto::MessageContextInfo* _msg = _internal_mutable_messagecontextinfo();
+  // @@protoc_insertion_point(field_mutable:proto.Message.messageContextInfo)
+  return _msg;
+}
+inline void Message::set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.messagecontextinfo_;
+  }
+  if (messagecontextinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagecontextinfo);
+    if (message_arena != submessage_arena) {
+      messagecontextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, messagecontextinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x04000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x04000000u;
+  }
+  _impl_.messagecontextinfo_ = messagecontextinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.messageContextInfo)
+}
+
+// optional .proto.Message.ListMessage listMessage = 36;
+inline bool Message::_internal_has_listmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.listmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_listmessage() const {
+  return _internal_has_listmessage();
+}
+inline void Message::clear_listmessage() {
+  if (_impl_.listmessage_ != nullptr) _impl_.listmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x08000000u;
+}
+inline const ::proto::Message_ListMessage& Message::_internal_listmessage() const {
+  const ::proto::Message_ListMessage* p = _impl_.listmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage&>(
+      ::proto::_Message_ListMessage_default_instance_);
+}
+inline const ::proto::Message_ListMessage& Message::listmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.listMessage)
+  return _internal_listmessage();
+}
+inline void Message::unsafe_arena_set_allocated_listmessage(
+    ::proto::Message_ListMessage* listmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listmessage_);
+  }
+  _impl_.listmessage_ = listmessage;
+  if (listmessage) {
+    _impl_._has_bits_[0] |= 0x08000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x08000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listMessage)
+}
+inline ::proto::Message_ListMessage* Message::release_listmessage() {
+  _impl_._has_bits_[0] &= ~0x08000000u;
+  ::proto::Message_ListMessage* temp = _impl_.listmessage_;
+  _impl_.listmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ListMessage* Message::unsafe_arena_release_listmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.listMessage)
+  _impl_._has_bits_[0] &= ~0x08000000u;
+  ::proto::Message_ListMessage* temp = _impl_.listmessage_;
+  _impl_.listmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ListMessage* Message::_internal_mutable_listmessage() {
+  _impl_._has_bits_[0] |= 0x08000000u;
+  if (_impl_.listmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ListMessage>(GetArenaForAllocation());
+    _impl_.listmessage_ = p;
+  }
+  return _impl_.listmessage_;
+}
+inline ::proto::Message_ListMessage* Message::mutable_listmessage() {
+  ::proto::Message_ListMessage* _msg = _internal_mutable_listmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.listMessage)
+  return _msg;
+}
+inline void Message::set_allocated_listmessage(::proto::Message_ListMessage* listmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.listmessage_;
+  }
+  if (listmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listmessage);
+    if (message_arena != submessage_arena) {
+      listmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, listmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x08000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x08000000u;
+  }
+  _impl_.listmessage_ = listmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.listMessage)
+}
+
+// optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
+inline bool Message::_internal_has_viewoncemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.viewoncemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_viewoncemessage() const {
+  return _internal_has_viewoncemessage();
+}
+inline void Message::clear_viewoncemessage() {
+  if (_impl_.viewoncemessage_ != nullptr) _impl_.viewoncemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x10000000u;
+}
+inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessage() const {
+  const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
+      ::proto::_Message_FutureProofMessage_default_instance_);
+}
+inline const ::proto::Message_FutureProofMessage& Message::viewoncemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessage)
+  return _internal_viewoncemessage();
+}
+inline void Message::unsafe_arena_set_allocated_viewoncemessage(
+    ::proto::Message_FutureProofMessage* viewoncemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessage_);
+  }
+  _impl_.viewoncemessage_ = viewoncemessage;
+  if (viewoncemessage) {
+    _impl_._has_bits_[0] |= 0x10000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x10000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessage)
+}
+inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessage() {
+  _impl_._has_bits_[0] &= ~0x10000000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_;
+  _impl_.viewoncemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessage)
+  _impl_._has_bits_[0] &= ~0x10000000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_;
+  _impl_.viewoncemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessage() {
+  _impl_._has_bits_[0] |= 0x10000000u;
+  if (_impl_.viewoncemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
+    _impl_.viewoncemessage_ = p;
+  }
+  return _impl_.viewoncemessage_;
+}
+inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessage() {
+  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessage)
+  return _msg;
+}
+inline void Message::set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.viewoncemessage_;
+  }
+  if (viewoncemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessage);
+    if (message_arena != submessage_arena) {
+      viewoncemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, viewoncemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x10000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x10000000u;
+  }
+  _impl_.viewoncemessage_ = viewoncemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessage)
+}
+
+// optional .proto.Message.OrderMessage orderMessage = 38;
+inline bool Message::_internal_has_ordermessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.ordermessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_ordermessage() const {
+  return _internal_has_ordermessage();
+}
+inline void Message::clear_ordermessage() {
+  if (_impl_.ordermessage_ != nullptr) _impl_.ordermessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x20000000u;
+}
+inline const ::proto::Message_OrderMessage& Message::_internal_ordermessage() const {
+  const ::proto::Message_OrderMessage* p = _impl_.ordermessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_OrderMessage&>(
+      ::proto::_Message_OrderMessage_default_instance_);
+}
+inline const ::proto::Message_OrderMessage& Message::ordermessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.orderMessage)
+  return _internal_ordermessage();
+}
+inline void Message::unsafe_arena_set_allocated_ordermessage(
+    ::proto::Message_OrderMessage* ordermessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ordermessage_);
+  }
+  _impl_.ordermessage_ = ordermessage;
+  if (ordermessage) {
+    _impl_._has_bits_[0] |= 0x20000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x20000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.orderMessage)
+}
+inline ::proto::Message_OrderMessage* Message::release_ordermessage() {
+  _impl_._has_bits_[0] &= ~0x20000000u;
+  ::proto::Message_OrderMessage* temp = _impl_.ordermessage_;
+  _impl_.ordermessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_OrderMessage* Message::unsafe_arena_release_ordermessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.orderMessage)
+  _impl_._has_bits_[0] &= ~0x20000000u;
+  ::proto::Message_OrderMessage* temp = _impl_.ordermessage_;
+  _impl_.ordermessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_OrderMessage* Message::_internal_mutable_ordermessage() {
+  _impl_._has_bits_[0] |= 0x20000000u;
+  if (_impl_.ordermessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_OrderMessage>(GetArenaForAllocation());
+    _impl_.ordermessage_ = p;
+  }
+  return _impl_.ordermessage_;
+}
+inline ::proto::Message_OrderMessage* Message::mutable_ordermessage() {
+  ::proto::Message_OrderMessage* _msg = _internal_mutable_ordermessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.orderMessage)
+  return _msg;
+}
+inline void Message::set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.ordermessage_;
+  }
+  if (ordermessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ordermessage);
+    if (message_arena != submessage_arena) {
+      ordermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, ordermessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x20000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x20000000u;
+  }
+  _impl_.ordermessage_ = ordermessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.orderMessage)
+}
+
+// optional .proto.Message.ListResponseMessage listResponseMessage = 39;
+inline bool Message::_internal_has_listresponsemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.listresponsemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_listresponsemessage() const {
+  return _internal_has_listresponsemessage();
+}
+inline void Message::clear_listresponsemessage() {
+  if (_impl_.listresponsemessage_ != nullptr) _impl_.listresponsemessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x40000000u;
+}
+inline const ::proto::Message_ListResponseMessage& Message::_internal_listresponsemessage() const {
+  const ::proto::Message_ListResponseMessage* p = _impl_.listresponsemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListResponseMessage&>(
+      ::proto::_Message_ListResponseMessage_default_instance_);
+}
+inline const ::proto::Message_ListResponseMessage& Message::listresponsemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.listResponseMessage)
+  return _internal_listresponsemessage();
+}
+inline void Message::unsafe_arena_set_allocated_listresponsemessage(
+    ::proto::Message_ListResponseMessage* listresponsemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listresponsemessage_);
+  }
+  _impl_.listresponsemessage_ = listresponsemessage;
+  if (listresponsemessage) {
+    _impl_._has_bits_[0] |= 0x40000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x40000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listResponseMessage)
+}
+inline ::proto::Message_ListResponseMessage* Message::release_listresponsemessage() {
+  _impl_._has_bits_[0] &= ~0x40000000u;
+  ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_;
+  _impl_.listresponsemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ListResponseMessage* Message::unsafe_arena_release_listresponsemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.listResponseMessage)
+  _impl_._has_bits_[0] &= ~0x40000000u;
+  ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_;
+  _impl_.listresponsemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ListResponseMessage* Message::_internal_mutable_listresponsemessage() {
+  _impl_._has_bits_[0] |= 0x40000000u;
+  if (_impl_.listresponsemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage>(GetArenaForAllocation());
+    _impl_.listresponsemessage_ = p;
+  }
+  return _impl_.listresponsemessage_;
+}
+inline ::proto::Message_ListResponseMessage* Message::mutable_listresponsemessage() {
+  ::proto::Message_ListResponseMessage* _msg = _internal_mutable_listresponsemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.listResponseMessage)
+  return _msg;
+}
+inline void Message::set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.listresponsemessage_;
+  }
+  if (listresponsemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listresponsemessage);
+    if (message_arena != submessage_arena) {
+      listresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, listresponsemessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x40000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x40000000u;
+  }
+  _impl_.listresponsemessage_ = listresponsemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.listResponseMessage)
+}
+
+// optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
+inline bool Message::_internal_has_ephemeralmessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.ephemeralmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_ephemeralmessage() const {
+  return _internal_has_ephemeralmessage();
+}
+inline void Message::clear_ephemeralmessage() {
+  if (_impl_.ephemeralmessage_ != nullptr) _impl_.ephemeralmessage_->Clear();
+  _impl_._has_bits_[0] &= ~0x80000000u;
+}
+inline const ::proto::Message_FutureProofMessage& Message::_internal_ephemeralmessage() const {
+  const ::proto::Message_FutureProofMessage* p = _impl_.ephemeralmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
+      ::proto::_Message_FutureProofMessage_default_instance_);
+}
+inline const ::proto::Message_FutureProofMessage& Message::ephemeralmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.ephemeralMessage)
+  return _internal_ephemeralmessage();
+}
+inline void Message::unsafe_arena_set_allocated_ephemeralmessage(
+    ::proto::Message_FutureProofMessage* ephemeralmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ephemeralmessage_);
+  }
+  _impl_.ephemeralmessage_ = ephemeralmessage;
+  if (ephemeralmessage) {
+    _impl_._has_bits_[0] |= 0x80000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x80000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ephemeralMessage)
+}
+inline ::proto::Message_FutureProofMessage* Message::release_ephemeralmessage() {
+  _impl_._has_bits_[0] &= ~0x80000000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_;
+  _impl_.ephemeralmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_ephemeralmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.ephemeralMessage)
+  _impl_._has_bits_[0] &= ~0x80000000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_;
+  _impl_.ephemeralmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_ephemeralmessage() {
+  _impl_._has_bits_[0] |= 0x80000000u;
+  if (_impl_.ephemeralmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
+    _impl_.ephemeralmessage_ = p;
+  }
+  return _impl_.ephemeralmessage_;
+}
+inline ::proto::Message_FutureProofMessage* Message::mutable_ephemeralmessage() {
+  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_ephemeralmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.ephemeralMessage)
+  return _msg;
+}
+inline void Message::set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.ephemeralmessage_;
+  }
+  if (ephemeralmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ephemeralmessage);
+    if (message_arena != submessage_arena) {
+      ephemeralmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, ephemeralmessage, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x80000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x80000000u;
+  }
+  _impl_.ephemeralmessage_ = ephemeralmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.ephemeralMessage)
+}
+
+// optional .proto.Message.InvoiceMessage invoiceMessage = 41;
+inline bool Message::_internal_has_invoicemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.invoicemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_invoicemessage() const {
+  return _internal_has_invoicemessage();
+}
+inline void Message::clear_invoicemessage() {
+  if (_impl_.invoicemessage_ != nullptr) _impl_.invoicemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000001u;
+}
+inline const ::proto::Message_InvoiceMessage& Message::_internal_invoicemessage() const {
+  const ::proto::Message_InvoiceMessage* p = _impl_.invoicemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InvoiceMessage&>(
+      ::proto::_Message_InvoiceMessage_default_instance_);
+}
+inline const ::proto::Message_InvoiceMessage& Message::invoicemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.invoiceMessage)
+  return _internal_invoicemessage();
+}
+inline void Message::unsafe_arena_set_allocated_invoicemessage(
+    ::proto::Message_InvoiceMessage* invoicemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.invoicemessage_);
+  }
+  _impl_.invoicemessage_ = invoicemessage;
+  if (invoicemessage) {
+    _impl_._has_bits_[1] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.invoiceMessage)
+}
+inline ::proto::Message_InvoiceMessage* Message::release_invoicemessage() {
+  _impl_._has_bits_[1] &= ~0x00000001u;
+  ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_;
+  _impl_.invoicemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InvoiceMessage* Message::unsafe_arena_release_invoicemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.invoiceMessage)
+  _impl_._has_bits_[1] &= ~0x00000001u;
+  ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_;
+  _impl_.invoicemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InvoiceMessage* Message::_internal_mutable_invoicemessage() {
+  _impl_._has_bits_[1] |= 0x00000001u;
+  if (_impl_.invoicemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InvoiceMessage>(GetArenaForAllocation());
+    _impl_.invoicemessage_ = p;
+  }
+  return _impl_.invoicemessage_;
+}
+inline ::proto::Message_InvoiceMessage* Message::mutable_invoicemessage() {
+  ::proto::Message_InvoiceMessage* _msg = _internal_mutable_invoicemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.invoiceMessage)
+  return _msg;
+}
+inline void Message::set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.invoicemessage_;
+  }
+  if (invoicemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invoicemessage);
+    if (message_arena != submessage_arena) {
+      invoicemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, invoicemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000001u;
+  }
+  _impl_.invoicemessage_ = invoicemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.invoiceMessage)
+}
+
+// optional .proto.Message.ButtonsMessage buttonsMessage = 42;
+inline bool Message::_internal_has_buttonsmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.buttonsmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_buttonsmessage() const {
+  return _internal_has_buttonsmessage();
+}
+inline void Message::clear_buttonsmessage() {
+  if (_impl_.buttonsmessage_ != nullptr) _impl_.buttonsmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000002u;
+}
+inline const ::proto::Message_ButtonsMessage& Message::_internal_buttonsmessage() const {
+  const ::proto::Message_ButtonsMessage* p = _impl_.buttonsmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage&>(
+      ::proto::_Message_ButtonsMessage_default_instance_);
+}
+inline const ::proto::Message_ButtonsMessage& Message::buttonsmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.buttonsMessage)
+  return _internal_buttonsmessage();
+}
+inline void Message::unsafe_arena_set_allocated_buttonsmessage(
+    ::proto::Message_ButtonsMessage* buttonsmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsmessage_);
+  }
+  _impl_.buttonsmessage_ = buttonsmessage;
+  if (buttonsmessage) {
+    _impl_._has_bits_[1] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsMessage)
+}
+inline ::proto::Message_ButtonsMessage* Message::release_buttonsmessage() {
+  _impl_._has_bits_[1] &= ~0x00000002u;
+  ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_;
+  _impl_.buttonsmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage* Message::unsafe_arena_release_buttonsmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.buttonsMessage)
+  _impl_._has_bits_[1] &= ~0x00000002u;
+  ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_;
+  _impl_.buttonsmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ButtonsMessage* Message::_internal_mutable_buttonsmessage() {
+  _impl_._has_bits_[1] |= 0x00000002u;
+  if (_impl_.buttonsmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage>(GetArenaForAllocation());
+    _impl_.buttonsmessage_ = p;
+  }
+  return _impl_.buttonsmessage_;
+}
+inline ::proto::Message_ButtonsMessage* Message::mutable_buttonsmessage() {
+  ::proto::Message_ButtonsMessage* _msg = _internal_mutable_buttonsmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.buttonsMessage)
+  return _msg;
+}
+inline void Message::set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.buttonsmessage_;
+  }
+  if (buttonsmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsmessage);
+    if (message_arena != submessage_arena) {
+      buttonsmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, buttonsmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000002u;
+  }
+  _impl_.buttonsmessage_ = buttonsmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsMessage)
+}
+
+// optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
+inline bool Message::_internal_has_buttonsresponsemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.buttonsresponsemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_buttonsresponsemessage() const {
+  return _internal_has_buttonsresponsemessage();
+}
+inline void Message::clear_buttonsresponsemessage() {
+  if (_impl_.buttonsresponsemessage_ != nullptr) _impl_.buttonsresponsemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000004u;
+}
+inline const ::proto::Message_ButtonsResponseMessage& Message::_internal_buttonsresponsemessage() const {
+  const ::proto::Message_ButtonsResponseMessage* p = _impl_.buttonsresponsemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsResponseMessage&>(
+      ::proto::_Message_ButtonsResponseMessage_default_instance_);
+}
+inline const ::proto::Message_ButtonsResponseMessage& Message::buttonsresponsemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.buttonsResponseMessage)
+  return _internal_buttonsresponsemessage();
+}
+inline void Message::unsafe_arena_set_allocated_buttonsresponsemessage(
+    ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsresponsemessage_);
+  }
+  _impl_.buttonsresponsemessage_ = buttonsresponsemessage;
+  if (buttonsresponsemessage) {
+    _impl_._has_bits_[1] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsResponseMessage)
+}
+inline ::proto::Message_ButtonsResponseMessage* Message::release_buttonsresponsemessage() {
+  _impl_._has_bits_[1] &= ~0x00000004u;
+  ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_;
+  _impl_.buttonsresponsemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ButtonsResponseMessage* Message::unsafe_arena_release_buttonsresponsemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.buttonsResponseMessage)
+  _impl_._has_bits_[1] &= ~0x00000004u;
+  ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_;
+  _impl_.buttonsresponsemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ButtonsResponseMessage* Message::_internal_mutable_buttonsresponsemessage() {
+  _impl_._has_bits_[1] |= 0x00000004u;
+  if (_impl_.buttonsresponsemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(GetArenaForAllocation());
+    _impl_.buttonsresponsemessage_ = p;
+  }
+  return _impl_.buttonsresponsemessage_;
+}
+inline ::proto::Message_ButtonsResponseMessage* Message::mutable_buttonsresponsemessage() {
+  ::proto::Message_ButtonsResponseMessage* _msg = _internal_mutable_buttonsresponsemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.buttonsResponseMessage)
+  return _msg;
+}
+inline void Message::set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.buttonsresponsemessage_;
+  }
+  if (buttonsresponsemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsresponsemessage);
+    if (message_arena != submessage_arena) {
+      buttonsresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, buttonsresponsemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000004u;
+  }
+  _impl_.buttonsresponsemessage_ = buttonsresponsemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsResponseMessage)
+}
+
+// optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
+inline bool Message::_internal_has_paymentinvitemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.paymentinvitemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_paymentinvitemessage() const {
+  return _internal_has_paymentinvitemessage();
+}
+inline void Message::clear_paymentinvitemessage() {
+  if (_impl_.paymentinvitemessage_ != nullptr) _impl_.paymentinvitemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000008u;
+}
+inline const ::proto::Message_PaymentInviteMessage& Message::_internal_paymentinvitemessage() const {
+  const ::proto::Message_PaymentInviteMessage* p = _impl_.paymentinvitemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PaymentInviteMessage&>(
+      ::proto::_Message_PaymentInviteMessage_default_instance_);
+}
+inline const ::proto::Message_PaymentInviteMessage& Message::paymentinvitemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.paymentInviteMessage)
+  return _internal_paymentinvitemessage();
+}
+inline void Message::unsafe_arena_set_allocated_paymentinvitemessage(
+    ::proto::Message_PaymentInviteMessage* paymentinvitemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinvitemessage_);
+  }
+  _impl_.paymentinvitemessage_ = paymentinvitemessage;
+  if (paymentinvitemessage) {
+    _impl_._has_bits_[1] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.paymentInviteMessage)
+}
+inline ::proto::Message_PaymentInviteMessage* Message::release_paymentinvitemessage() {
+  _impl_._has_bits_[1] &= ~0x00000008u;
+  ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_;
+  _impl_.paymentinvitemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PaymentInviteMessage* Message::unsafe_arena_release_paymentinvitemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.paymentInviteMessage)
+  _impl_._has_bits_[1] &= ~0x00000008u;
+  ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_;
+  _impl_.paymentinvitemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PaymentInviteMessage* Message::_internal_mutable_paymentinvitemessage() {
+  _impl_._has_bits_[1] |= 0x00000008u;
+  if (_impl_.paymentinvitemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(GetArenaForAllocation());
+    _impl_.paymentinvitemessage_ = p;
+  }
+  return _impl_.paymentinvitemessage_;
+}
+inline ::proto::Message_PaymentInviteMessage* Message::mutable_paymentinvitemessage() {
+  ::proto::Message_PaymentInviteMessage* _msg = _internal_mutable_paymentinvitemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.paymentInviteMessage)
+  return _msg;
+}
+inline void Message::set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.paymentinvitemessage_;
+  }
+  if (paymentinvitemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinvitemessage);
+    if (message_arena != submessage_arena) {
+      paymentinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, paymentinvitemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000008u;
+  }
+  _impl_.paymentinvitemessage_ = paymentinvitemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.paymentInviteMessage)
+}
+
+// optional .proto.Message.InteractiveMessage interactiveMessage = 45;
+inline bool Message::_internal_has_interactivemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.interactivemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_interactivemessage() const {
+  return _internal_has_interactivemessage();
+}
+inline void Message::clear_interactivemessage() {
+  if (_impl_.interactivemessage_ != nullptr) _impl_.interactivemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000010u;
+}
+inline const ::proto::Message_InteractiveMessage& Message::_internal_interactivemessage() const {
+  const ::proto::Message_InteractiveMessage* p = _impl_.interactivemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage&>(
+      ::proto::_Message_InteractiveMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveMessage& Message::interactivemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.interactiveMessage)
+  return _internal_interactivemessage();
+}
+inline void Message::unsafe_arena_set_allocated_interactivemessage(
+    ::proto::Message_InteractiveMessage* interactivemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactivemessage_);
+  }
+  _impl_.interactivemessage_ = interactivemessage;
+  if (interactivemessage) {
+    _impl_._has_bits_[1] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveMessage)
+}
+inline ::proto::Message_InteractiveMessage* Message::release_interactivemessage() {
+  _impl_._has_bits_[1] &= ~0x00000010u;
+  ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_;
+  _impl_.interactivemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage* Message::unsafe_arena_release_interactivemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.interactiveMessage)
+  _impl_._has_bits_[1] &= ~0x00000010u;
+  ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_;
+  _impl_.interactivemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveMessage* Message::_internal_mutable_interactivemessage() {
+  _impl_._has_bits_[1] |= 0x00000010u;
+  if (_impl_.interactivemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage>(GetArenaForAllocation());
+    _impl_.interactivemessage_ = p;
+  }
+  return _impl_.interactivemessage_;
+}
+inline ::proto::Message_InteractiveMessage* Message::mutable_interactivemessage() {
+  ::proto::Message_InteractiveMessage* _msg = _internal_mutable_interactivemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.interactiveMessage)
+  return _msg;
+}
+inline void Message::set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.interactivemessage_;
+  }
+  if (interactivemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactivemessage);
+    if (message_arena != submessage_arena) {
+      interactivemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interactivemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000010u;
+  }
+  _impl_.interactivemessage_ = interactivemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveMessage)
+}
+
+// optional .proto.Message.ReactionMessage reactionMessage = 46;
+inline bool Message::_internal_has_reactionmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.reactionmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_reactionmessage() const {
+  return _internal_has_reactionmessage();
+}
+inline void Message::clear_reactionmessage() {
+  if (_impl_.reactionmessage_ != nullptr) _impl_.reactionmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000020u;
+}
+inline const ::proto::Message_ReactionMessage& Message::_internal_reactionmessage() const {
+  const ::proto::Message_ReactionMessage* p = _impl_.reactionmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ReactionMessage&>(
+      ::proto::_Message_ReactionMessage_default_instance_);
+}
+inline const ::proto::Message_ReactionMessage& Message::reactionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.reactionMessage)
+  return _internal_reactionmessage();
+}
+inline void Message::unsafe_arena_set_allocated_reactionmessage(
+    ::proto::Message_ReactionMessage* reactionmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reactionmessage_);
+  }
+  _impl_.reactionmessage_ = reactionmessage;
+  if (reactionmessage) {
+    _impl_._has_bits_[1] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.reactionMessage)
+}
+inline ::proto::Message_ReactionMessage* Message::release_reactionmessage() {
+  _impl_._has_bits_[1] &= ~0x00000020u;
+  ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_;
+  _impl_.reactionmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_ReactionMessage* Message::unsafe_arena_release_reactionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.reactionMessage)
+  _impl_._has_bits_[1] &= ~0x00000020u;
+  ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_;
+  _impl_.reactionmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_ReactionMessage* Message::_internal_mutable_reactionmessage() {
+  _impl_._has_bits_[1] |= 0x00000020u;
+  if (_impl_.reactionmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_ReactionMessage>(GetArenaForAllocation());
+    _impl_.reactionmessage_ = p;
+  }
+  return _impl_.reactionmessage_;
+}
+inline ::proto::Message_ReactionMessage* Message::mutable_reactionmessage() {
+  ::proto::Message_ReactionMessage* _msg = _internal_mutable_reactionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.reactionMessage)
+  return _msg;
+}
+inline void Message::set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.reactionmessage_;
+  }
+  if (reactionmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reactionmessage);
+    if (message_arena != submessage_arena) {
+      reactionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, reactionmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000020u;
+  }
+  _impl_.reactionmessage_ = reactionmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.reactionMessage)
+}
+
+// optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+inline bool Message::_internal_has_stickersyncrmrmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.stickersyncrmrmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_stickersyncrmrmessage() const {
+  return _internal_has_stickersyncrmrmessage();
+}
+inline void Message::clear_stickersyncrmrmessage() {
+  if (_impl_.stickersyncrmrmessage_ != nullptr) _impl_.stickersyncrmrmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000040u;
+}
+inline const ::proto::Message_StickerSyncRMRMessage& Message::_internal_stickersyncrmrmessage() const {
+  const ::proto::Message_StickerSyncRMRMessage* p = _impl_.stickersyncrmrmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerSyncRMRMessage&>(
+      ::proto::_Message_StickerSyncRMRMessage_default_instance_);
+}
+inline const ::proto::Message_StickerSyncRMRMessage& Message::stickersyncrmrmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.stickerSyncRmrMessage)
+  return _internal_stickersyncrmrmessage();
+}
+inline void Message::unsafe_arena_set_allocated_stickersyncrmrmessage(
+    ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickersyncrmrmessage_);
+  }
+  _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage;
+  if (stickersyncrmrmessage) {
+    _impl_._has_bits_[1] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerSyncRmrMessage)
+}
+inline ::proto::Message_StickerSyncRMRMessage* Message::release_stickersyncrmrmessage() {
+  _impl_._has_bits_[1] &= ~0x00000040u;
+  ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_;
+  _impl_.stickersyncrmrmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_StickerSyncRMRMessage* Message::unsafe_arena_release_stickersyncrmrmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.stickerSyncRmrMessage)
+  _impl_._has_bits_[1] &= ~0x00000040u;
+  ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_;
+  _impl_.stickersyncrmrmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_StickerSyncRMRMessage* Message::_internal_mutable_stickersyncrmrmessage() {
+  _impl_._has_bits_[1] |= 0x00000040u;
+  if (_impl_.stickersyncrmrmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(GetArenaForAllocation());
+    _impl_.stickersyncrmrmessage_ = p;
+  }
+  return _impl_.stickersyncrmrmessage_;
+}
+inline ::proto::Message_StickerSyncRMRMessage* Message::mutable_stickersyncrmrmessage() {
+  ::proto::Message_StickerSyncRMRMessage* _msg = _internal_mutable_stickersyncrmrmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.stickerSyncRmrMessage)
+  return _msg;
+}
+inline void Message::set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.stickersyncrmrmessage_;
+  }
+  if (stickersyncrmrmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickersyncrmrmessage);
+    if (message_arena != submessage_arena) {
+      stickersyncrmrmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, stickersyncrmrmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000040u;
+  }
+  _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerSyncRmrMessage)
+}
+
+// optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
+inline bool Message::_internal_has_interactiveresponsemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.interactiveresponsemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_interactiveresponsemessage() const {
+  return _internal_has_interactiveresponsemessage();
+}
+inline void Message::clear_interactiveresponsemessage() {
+  if (_impl_.interactiveresponsemessage_ != nullptr) _impl_.interactiveresponsemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000080u;
+}
+inline const ::proto::Message_InteractiveResponseMessage& Message::_internal_interactiveresponsemessage() const {
+  const ::proto::Message_InteractiveResponseMessage* p = _impl_.interactiveresponsemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveResponseMessage&>(
+      ::proto::_Message_InteractiveResponseMessage_default_instance_);
+}
+inline const ::proto::Message_InteractiveResponseMessage& Message::interactiveresponsemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.interactiveResponseMessage)
+  return _internal_interactiveresponsemessage();
+}
+inline void Message::unsafe_arena_set_allocated_interactiveresponsemessage(
+    ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactiveresponsemessage_);
+  }
+  _impl_.interactiveresponsemessage_ = interactiveresponsemessage;
+  if (interactiveresponsemessage) {
+    _impl_._has_bits_[1] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveResponseMessage)
+}
+inline ::proto::Message_InteractiveResponseMessage* Message::release_interactiveresponsemessage() {
+  _impl_._has_bits_[1] &= ~0x00000080u;
+  ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_;
+  _impl_.interactiveresponsemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_InteractiveResponseMessage* Message::unsafe_arena_release_interactiveresponsemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.interactiveResponseMessage)
+  _impl_._has_bits_[1] &= ~0x00000080u;
+  ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_;
+  _impl_.interactiveresponsemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_InteractiveResponseMessage* Message::_internal_mutable_interactiveresponsemessage() {
+  _impl_._has_bits_[1] |= 0x00000080u;
+  if (_impl_.interactiveresponsemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(GetArenaForAllocation());
+    _impl_.interactiveresponsemessage_ = p;
+  }
+  return _impl_.interactiveresponsemessage_;
+}
+inline ::proto::Message_InteractiveResponseMessage* Message::mutable_interactiveresponsemessage() {
+  ::proto::Message_InteractiveResponseMessage* _msg = _internal_mutable_interactiveresponsemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.interactiveResponseMessage)
+  return _msg;
+}
+inline void Message::set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.interactiveresponsemessage_;
+  }
+  if (interactiveresponsemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactiveresponsemessage);
+    if (message_arena != submessage_arena) {
+      interactiveresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interactiveresponsemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000080u;
+  }
+  _impl_.interactiveresponsemessage_ = interactiveresponsemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveResponseMessage)
+}
+
+// optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
+inline bool Message::_internal_has_pollcreationmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pollcreationmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_pollcreationmessage() const {
+  return _internal_has_pollcreationmessage();
+}
+inline void Message::clear_pollcreationmessage() {
+  if (_impl_.pollcreationmessage_ != nullptr) _impl_.pollcreationmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000100u;
+}
+inline const ::proto::Message_PollCreationMessage& Message::_internal_pollcreationmessage() const {
+  const ::proto::Message_PollCreationMessage* p = _impl_.pollcreationmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollCreationMessage&>(
+      ::proto::_Message_PollCreationMessage_default_instance_);
+}
+inline const ::proto::Message_PollCreationMessage& Message::pollcreationmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.pollCreationMessage)
+  return _internal_pollcreationmessage();
+}
+inline void Message::unsafe_arena_set_allocated_pollcreationmessage(
+    ::proto::Message_PollCreationMessage* pollcreationmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessage_);
+  }
+  _impl_.pollcreationmessage_ = pollcreationmessage;
+  if (pollcreationmessage) {
+    _impl_._has_bits_[1] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollCreationMessage)
+}
+inline ::proto::Message_PollCreationMessage* Message::release_pollcreationmessage() {
+  _impl_._has_bits_[1] &= ~0x00000100u;
+  ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_;
+  _impl_.pollcreationmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PollCreationMessage* Message::unsafe_arena_release_pollcreationmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.pollCreationMessage)
+  _impl_._has_bits_[1] &= ~0x00000100u;
+  ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_;
+  _impl_.pollcreationmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PollCreationMessage* Message::_internal_mutable_pollcreationmessage() {
+  _impl_._has_bits_[1] |= 0x00000100u;
+  if (_impl_.pollcreationmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PollCreationMessage>(GetArenaForAllocation());
+    _impl_.pollcreationmessage_ = p;
+  }
+  return _impl_.pollcreationmessage_;
+}
+inline ::proto::Message_PollCreationMessage* Message::mutable_pollcreationmessage() {
+  ::proto::Message_PollCreationMessage* _msg = _internal_mutable_pollcreationmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.pollCreationMessage)
+  return _msg;
+}
+inline void Message::set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pollcreationmessage_;
+  }
+  if (pollcreationmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessage);
+    if (message_arena != submessage_arena) {
+      pollcreationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pollcreationmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000100u;
+  }
+  _impl_.pollcreationmessage_ = pollcreationmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.pollCreationMessage)
+}
+
+// optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
+inline bool Message::_internal_has_pollupdatemessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pollupdatemessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_pollupdatemessage() const {
+  return _internal_has_pollupdatemessage();
+}
+inline void Message::clear_pollupdatemessage() {
+  if (_impl_.pollupdatemessage_ != nullptr) _impl_.pollupdatemessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000200u;
+}
+inline const ::proto::Message_PollUpdateMessage& Message::_internal_pollupdatemessage() const {
+  const ::proto::Message_PollUpdateMessage* p = _impl_.pollupdatemessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollUpdateMessage&>(
+      ::proto::_Message_PollUpdateMessage_default_instance_);
+}
+inline const ::proto::Message_PollUpdateMessage& Message::pollupdatemessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.pollUpdateMessage)
+  return _internal_pollupdatemessage();
+}
+inline void Message::unsafe_arena_set_allocated_pollupdatemessage(
+    ::proto::Message_PollUpdateMessage* pollupdatemessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessage_);
+  }
+  _impl_.pollupdatemessage_ = pollupdatemessage;
+  if (pollupdatemessage) {
+    _impl_._has_bits_[1] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000200u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollUpdateMessage)
+}
+inline ::proto::Message_PollUpdateMessage* Message::release_pollupdatemessage() {
+  _impl_._has_bits_[1] &= ~0x00000200u;
+  ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_;
+  _impl_.pollupdatemessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PollUpdateMessage* Message::unsafe_arena_release_pollupdatemessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.pollUpdateMessage)
+  _impl_._has_bits_[1] &= ~0x00000200u;
+  ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_;
+  _impl_.pollupdatemessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PollUpdateMessage* Message::_internal_mutable_pollupdatemessage() {
+  _impl_._has_bits_[1] |= 0x00000200u;
+  if (_impl_.pollupdatemessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessage>(GetArenaForAllocation());
+    _impl_.pollupdatemessage_ = p;
+  }
+  return _impl_.pollupdatemessage_;
+}
+inline ::proto::Message_PollUpdateMessage* Message::mutable_pollupdatemessage() {
+  ::proto::Message_PollUpdateMessage* _msg = _internal_mutable_pollupdatemessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.pollUpdateMessage)
+  return _msg;
+}
+inline void Message::set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pollupdatemessage_;
+  }
+  if (pollupdatemessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessage);
+    if (message_arena != submessage_arena) {
+      pollupdatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pollupdatemessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000200u;
+  }
+  _impl_.pollupdatemessage_ = pollupdatemessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.pollUpdateMessage)
+}
+
+// optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
+inline bool Message::_internal_has_keepinchatmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keepinchatmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_keepinchatmessage() const {
+  return _internal_has_keepinchatmessage();
+}
+inline void Message::clear_keepinchatmessage() {
+  if (_impl_.keepinchatmessage_ != nullptr) _impl_.keepinchatmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000400u;
+}
+inline const ::proto::Message_KeepInChatMessage& Message::_internal_keepinchatmessage() const {
+  const ::proto::Message_KeepInChatMessage* p = _impl_.keepinchatmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_KeepInChatMessage&>(
+      ::proto::_Message_KeepInChatMessage_default_instance_);
+}
+inline const ::proto::Message_KeepInChatMessage& Message::keepinchatmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.keepInChatMessage)
+  return _internal_keepinchatmessage();
+}
+inline void Message::unsafe_arena_set_allocated_keepinchatmessage(
+    ::proto::Message_KeepInChatMessage* keepinchatmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchatmessage_);
+  }
+  _impl_.keepinchatmessage_ = keepinchatmessage;
+  if (keepinchatmessage) {
+    _impl_._has_bits_[1] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.keepInChatMessage)
+}
+inline ::proto::Message_KeepInChatMessage* Message::release_keepinchatmessage() {
+  _impl_._has_bits_[1] &= ~0x00000400u;
+  ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_;
+  _impl_.keepinchatmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_KeepInChatMessage* Message::unsafe_arena_release_keepinchatmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.keepInChatMessage)
+  _impl_._has_bits_[1] &= ~0x00000400u;
+  ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_;
+  _impl_.keepinchatmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_KeepInChatMessage* Message::_internal_mutable_keepinchatmessage() {
+  _impl_._has_bits_[1] |= 0x00000400u;
+  if (_impl_.keepinchatmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_KeepInChatMessage>(GetArenaForAllocation());
+    _impl_.keepinchatmessage_ = p;
+  }
+  return _impl_.keepinchatmessage_;
+}
+inline ::proto::Message_KeepInChatMessage* Message::mutable_keepinchatmessage() {
+  ::proto::Message_KeepInChatMessage* _msg = _internal_mutable_keepinchatmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.keepInChatMessage)
+  return _msg;
+}
+inline void Message::set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keepinchatmessage_;
+  }
+  if (keepinchatmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchatmessage);
+    if (message_arena != submessage_arena) {
+      keepinchatmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keepinchatmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000400u;
+  }
+  _impl_.keepinchatmessage_ = keepinchatmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.keepInChatMessage)
+}
+
+// optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
+inline bool Message::_internal_has_documentwithcaptionmessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.documentwithcaptionmessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_documentwithcaptionmessage() const {
+  return _internal_has_documentwithcaptionmessage();
+}
+inline void Message::clear_documentwithcaptionmessage() {
+  if (_impl_.documentwithcaptionmessage_ != nullptr) _impl_.documentwithcaptionmessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00000800u;
+}
+inline const ::proto::Message_FutureProofMessage& Message::_internal_documentwithcaptionmessage() const {
+  const ::proto::Message_FutureProofMessage* p = _impl_.documentwithcaptionmessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
+      ::proto::_Message_FutureProofMessage_default_instance_);
+}
+inline const ::proto::Message_FutureProofMessage& Message::documentwithcaptionmessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.documentWithCaptionMessage)
+  return _internal_documentwithcaptionmessage();
+}
+inline void Message::unsafe_arena_set_allocated_documentwithcaptionmessage(
+    ::proto::Message_FutureProofMessage* documentwithcaptionmessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentwithcaptionmessage_);
+  }
+  _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage;
+  if (documentwithcaptionmessage) {
+    _impl_._has_bits_[1] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000800u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentWithCaptionMessage)
+}
+inline ::proto::Message_FutureProofMessage* Message::release_documentwithcaptionmessage() {
+  _impl_._has_bits_[1] &= ~0x00000800u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_;
+  _impl_.documentwithcaptionmessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_documentwithcaptionmessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.documentWithCaptionMessage)
+  _impl_._has_bits_[1] &= ~0x00000800u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_;
+  _impl_.documentwithcaptionmessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_documentwithcaptionmessage() {
+  _impl_._has_bits_[1] |= 0x00000800u;
+  if (_impl_.documentwithcaptionmessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
+    _impl_.documentwithcaptionmessage_ = p;
+  }
+  return _impl_.documentwithcaptionmessage_;
+}
+inline ::proto::Message_FutureProofMessage* Message::mutable_documentwithcaptionmessage() {
+  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_documentwithcaptionmessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.documentWithCaptionMessage)
+  return _msg;
+}
+inline void Message::set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.documentwithcaptionmessage_;
+  }
+  if (documentwithcaptionmessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentwithcaptionmessage);
+    if (message_arena != submessage_arena) {
+      documentwithcaptionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, documentwithcaptionmessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00000800u;
+  }
+  _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.documentWithCaptionMessage)
+}
+
+// optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+inline bool Message::_internal_has_requestphonenumbermessage() const {
+  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestphonenumbermessage_ != nullptr);
+  return value;
+}
+inline bool Message::has_requestphonenumbermessage() const {
+  return _internal_has_requestphonenumbermessage();
+}
+inline void Message::clear_requestphonenumbermessage() {
+  if (_impl_.requestphonenumbermessage_ != nullptr) _impl_.requestphonenumbermessage_->Clear();
+  _impl_._has_bits_[1] &= ~0x00001000u;
+}
+inline const ::proto::Message_RequestPhoneNumberMessage& Message::_internal_requestphonenumbermessage() const {
+  const ::proto::Message_RequestPhoneNumberMessage* p = _impl_.requestphonenumbermessage_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestPhoneNumberMessage&>(
+      ::proto::_Message_RequestPhoneNumberMessage_default_instance_);
+}
+inline const ::proto::Message_RequestPhoneNumberMessage& Message::requestphonenumbermessage() const {
+  // @@protoc_insertion_point(field_get:proto.Message.requestPhoneNumberMessage)
+  return _internal_requestphonenumbermessage();
+}
+inline void Message::unsafe_arena_set_allocated_requestphonenumbermessage(
+    ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestphonenumbermessage_);
+  }
+  _impl_.requestphonenumbermessage_ = requestphonenumbermessage;
+  if (requestphonenumbermessage) {
+    _impl_._has_bits_[1] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPhoneNumberMessage)
+}
+inline ::proto::Message_RequestPhoneNumberMessage* Message::release_requestphonenumbermessage() {
+  _impl_._has_bits_[1] &= ~0x00001000u;
+  ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_;
+  _impl_.requestphonenumbermessage_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_RequestPhoneNumberMessage* Message::unsafe_arena_release_requestphonenumbermessage() {
+  // @@protoc_insertion_point(field_release:proto.Message.requestPhoneNumberMessage)
+  _impl_._has_bits_[1] &= ~0x00001000u;
+  ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_;
+  _impl_.requestphonenumbermessage_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_RequestPhoneNumberMessage* Message::_internal_mutable_requestphonenumbermessage() {
+  _impl_._has_bits_[1] |= 0x00001000u;
+  if (_impl_.requestphonenumbermessage_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(GetArenaForAllocation());
+    _impl_.requestphonenumbermessage_ = p;
+  }
+  return _impl_.requestphonenumbermessage_;
+}
+inline ::proto::Message_RequestPhoneNumberMessage* Message::mutable_requestphonenumbermessage() {
+  ::proto::Message_RequestPhoneNumberMessage* _msg = _internal_mutable_requestphonenumbermessage();
+  // @@protoc_insertion_point(field_mutable:proto.Message.requestPhoneNumberMessage)
+  return _msg;
+}
+inline void Message::set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestphonenumbermessage_;
+  }
+  if (requestphonenumbermessage) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestphonenumbermessage);
+    if (message_arena != submessage_arena) {
+      requestphonenumbermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestphonenumbermessage, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00001000u;
+  }
+  _impl_.requestphonenumbermessage_ = requestphonenumbermessage;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPhoneNumberMessage)
+}
+
+// optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
+inline bool Message::_internal_has_viewoncemessagev2() const {
+  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.viewoncemessagev2_ != nullptr);
+  return value;
+}
+inline bool Message::has_viewoncemessagev2() const {
+  return _internal_has_viewoncemessagev2();
+}
+inline void Message::clear_viewoncemessagev2() {
+  if (_impl_.viewoncemessagev2_ != nullptr) _impl_.viewoncemessagev2_->Clear();
+  _impl_._has_bits_[1] &= ~0x00002000u;
+}
+inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessagev2() const {
+  const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessagev2_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
+      ::proto::_Message_FutureProofMessage_default_instance_);
+}
+inline const ::proto::Message_FutureProofMessage& Message::viewoncemessagev2() const {
+  // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessageV2)
+  return _internal_viewoncemessagev2();
+}
+inline void Message::unsafe_arena_set_allocated_viewoncemessagev2(
+    ::proto::Message_FutureProofMessage* viewoncemessagev2) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessagev2_);
+  }
+  _impl_.viewoncemessagev2_ = viewoncemessagev2;
+  if (viewoncemessagev2) {
+    _impl_._has_bits_[1] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessageV2)
+}
+inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessagev2() {
+  _impl_._has_bits_[1] &= ~0x00002000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_;
+  _impl_.viewoncemessagev2_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessagev2() {
+  // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessageV2)
+  _impl_._has_bits_[1] &= ~0x00002000u;
+  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_;
+  _impl_.viewoncemessagev2_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessagev2() {
+  _impl_._has_bits_[1] |= 0x00002000u;
+  if (_impl_.viewoncemessagev2_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
+    _impl_.viewoncemessagev2_ = p;
+  }
+  return _impl_.viewoncemessagev2_;
+}
+inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessagev2() {
+  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessagev2();
+  // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessageV2)
+  return _msg;
+}
+inline void Message::set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.viewoncemessagev2_;
+  }
+  if (viewoncemessagev2) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessagev2);
+    if (message_arena != submessage_arena) {
+      viewoncemessagev2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, viewoncemessagev2, submessage_arena);
+    }
+    _impl_._has_bits_[1] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[1] &= ~0x00002000u;
+  }
+  _impl_.viewoncemessagev2_ = viewoncemessagev2;
+  // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessageV2)
+}
+
+// -------------------------------------------------------------------
+
+// MessageContextInfo
+
+// optional .proto.DeviceListMetadata deviceListMetadata = 1;
+inline bool MessageContextInfo::_internal_has_devicelistmetadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.devicelistmetadata_ != nullptr);
+  return value;
+}
+inline bool MessageContextInfo::has_devicelistmetadata() const {
+  return _internal_has_devicelistmetadata();
+}
+inline void MessageContextInfo::clear_devicelistmetadata() {
+  if (_impl_.devicelistmetadata_ != nullptr) _impl_.devicelistmetadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::DeviceListMetadata& MessageContextInfo::_internal_devicelistmetadata() const {
+  const ::proto::DeviceListMetadata* p = _impl_.devicelistmetadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::DeviceListMetadata&>(
+      ::proto::_DeviceListMetadata_default_instance_);
+}
+inline const ::proto::DeviceListMetadata& MessageContextInfo::devicelistmetadata() const {
+  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadata)
+  return _internal_devicelistmetadata();
+}
+inline void MessageContextInfo::unsafe_arena_set_allocated_devicelistmetadata(
+    ::proto::DeviceListMetadata* devicelistmetadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicelistmetadata_);
+  }
+  _impl_.devicelistmetadata_ = devicelistmetadata;
+  if (devicelistmetadata) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MessageContextInfo.deviceListMetadata)
+}
+inline ::proto::DeviceListMetadata* MessageContextInfo::release_devicelistmetadata() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_;
+  _impl_.devicelistmetadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::DeviceListMetadata* MessageContextInfo::unsafe_arena_release_devicelistmetadata() {
+  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.deviceListMetadata)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_;
+  _impl_.devicelistmetadata_ = nullptr;
+  return temp;
+}
+inline ::proto::DeviceListMetadata* MessageContextInfo::_internal_mutable_devicelistmetadata() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.devicelistmetadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::DeviceListMetadata>(GetArenaForAllocation());
+    _impl_.devicelistmetadata_ = p;
+  }
+  return _impl_.devicelistmetadata_;
+}
+inline ::proto::DeviceListMetadata* MessageContextInfo::mutable_devicelistmetadata() {
+  ::proto::DeviceListMetadata* _msg = _internal_mutable_devicelistmetadata();
+  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.deviceListMetadata)
+  return _msg;
+}
+inline void MessageContextInfo::set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.devicelistmetadata_;
+  }
+  if (devicelistmetadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicelistmetadata);
+    if (message_arena != submessage_arena) {
+      devicelistmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, devicelistmetadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.devicelistmetadata_ = devicelistmetadata;
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.deviceListMetadata)
+}
+
+// optional int32 deviceListMetadataVersion = 2;
+inline bool MessageContextInfo::_internal_has_devicelistmetadataversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool MessageContextInfo::has_devicelistmetadataversion() const {
+  return _internal_has_devicelistmetadataversion();
+}
+inline void MessageContextInfo::clear_devicelistmetadataversion() {
+  _impl_.devicelistmetadataversion_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t MessageContextInfo::_internal_devicelistmetadataversion() const {
+  return _impl_.devicelistmetadataversion_;
+}
+inline int32_t MessageContextInfo::devicelistmetadataversion() const {
+  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadataVersion)
+  return _internal_devicelistmetadataversion();
+}
+inline void MessageContextInfo::_internal_set_devicelistmetadataversion(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.devicelistmetadataversion_ = value;
+}
+inline void MessageContextInfo::set_devicelistmetadataversion(int32_t value) {
+  _internal_set_devicelistmetadataversion(value);
+  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.deviceListMetadataVersion)
+}
+
+// optional bytes messageSecret = 3;
+inline bool MessageContextInfo::_internal_has_messagesecret() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MessageContextInfo::has_messagesecret() const {
+  return _internal_has_messagesecret();
+}
+inline void MessageContextInfo::clear_messagesecret() {
+  _impl_.messagesecret_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MessageContextInfo::messagesecret() const {
+  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.messageSecret)
+  return _internal_messagesecret();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MessageContextInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.messageSecret)
+}
+inline std::string* MessageContextInfo::mutable_messagesecret() {
+  std::string* _s = _internal_mutable_messagesecret();
+  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.messageSecret)
+  return _s;
+}
+inline const std::string& MessageContextInfo::_internal_messagesecret() const {
+  return _impl_.messagesecret_.Get();
+}
+inline void MessageContextInfo::_internal_set_messagesecret(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MessageContextInfo::_internal_mutable_messagesecret() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MessageContextInfo::release_messagesecret() {
+  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.messageSecret)
+  if (!_internal_has_messagesecret()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.messagesecret_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MessageContextInfo::set_allocated_messagesecret(std::string* messagesecret) {
+  if (messagesecret != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.messageSecret)
+}
+
+// optional bytes paddingBytes = 4;
+inline bool MessageContextInfo::_internal_has_paddingbytes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MessageContextInfo::has_paddingbytes() const {
+  return _internal_has_paddingbytes();
+}
+inline void MessageContextInfo::clear_paddingbytes() {
+  _impl_.paddingbytes_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MessageContextInfo::paddingbytes() const {
+  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.paddingBytes)
+  return _internal_paddingbytes();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MessageContextInfo::set_paddingbytes(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.paddingbytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.paddingBytes)
+}
+inline std::string* MessageContextInfo::mutable_paddingbytes() {
+  std::string* _s = _internal_mutable_paddingbytes();
+  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.paddingBytes)
+  return _s;
+}
+inline const std::string& MessageContextInfo::_internal_paddingbytes() const {
+  return _impl_.paddingbytes_.Get();
+}
+inline void MessageContextInfo::_internal_set_paddingbytes(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.paddingbytes_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MessageContextInfo::_internal_mutable_paddingbytes() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.paddingbytes_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MessageContextInfo::release_paddingbytes() {
+  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.paddingBytes)
+  if (!_internal_has_paddingbytes()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.paddingbytes_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paddingbytes_.IsDefault()) {
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MessageContextInfo::set_allocated_paddingbytes(std::string* paddingbytes) {
+  if (paddingbytes != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paddingbytes_.IsDefault()) {
+    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.paddingBytes)
+}
+
+// -------------------------------------------------------------------
+
+// MessageKey
+
+// optional string remoteJid = 1;
+inline bool MessageKey::_internal_has_remotejid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MessageKey::has_remotejid() const {
+  return _internal_has_remotejid();
+}
+inline void MessageKey::clear_remotejid() {
+  _impl_.remotejid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MessageKey::remotejid() const {
+  // @@protoc_insertion_point(field_get:proto.MessageKey.remoteJid)
+  return _internal_remotejid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MessageKey::set_remotejid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.remotejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MessageKey.remoteJid)
+}
+inline std::string* MessageKey::mutable_remotejid() {
+  std::string* _s = _internal_mutable_remotejid();
+  // @@protoc_insertion_point(field_mutable:proto.MessageKey.remoteJid)
+  return _s;
+}
+inline const std::string& MessageKey::_internal_remotejid() const {
+  return _impl_.remotejid_.Get();
+}
+inline void MessageKey::_internal_set_remotejid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.remotejid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MessageKey::_internal_mutable_remotejid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.remotejid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MessageKey::release_remotejid() {
+  // @@protoc_insertion_point(field_release:proto.MessageKey.remoteJid)
+  if (!_internal_has_remotejid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.remotejid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remotejid_.IsDefault()) {
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MessageKey::set_allocated_remotejid(std::string* remotejid) {
+  if (remotejid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remotejid_.IsDefault()) {
+    _impl_.remotejid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.remoteJid)
+}
+
+// optional bool fromMe = 2;
+inline bool MessageKey::_internal_has_fromme() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool MessageKey::has_fromme() const {
+  return _internal_has_fromme();
+}
+inline void MessageKey::clear_fromme() {
+  _impl_.fromme_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool MessageKey::_internal_fromme() const {
+  return _impl_.fromme_;
+}
+inline bool MessageKey::fromme() const {
+  // @@protoc_insertion_point(field_get:proto.MessageKey.fromMe)
+  return _internal_fromme();
+}
+inline void MessageKey::_internal_set_fromme(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.fromme_ = value;
+}
+inline void MessageKey::set_fromme(bool value) {
+  _internal_set_fromme(value);
+  // @@protoc_insertion_point(field_set:proto.MessageKey.fromMe)
+}
+
+// optional string id = 3;
+inline bool MessageKey::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MessageKey::has_id() const {
+  return _internal_has_id();
+}
+inline void MessageKey::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MessageKey::id() const {
+  // @@protoc_insertion_point(field_get:proto.MessageKey.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MessageKey::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MessageKey.id)
+}
+inline std::string* MessageKey::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.MessageKey.id)
+  return _s;
+}
+inline const std::string& MessageKey::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void MessageKey::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MessageKey::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MessageKey::release_id() {
+  // @@protoc_insertion_point(field_release:proto.MessageKey.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MessageKey::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.id)
+}
+
+// optional string participant = 4;
+inline bool MessageKey::_internal_has_participant() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MessageKey::has_participant() const {
+  return _internal_has_participant();
+}
+inline void MessageKey::clear_participant() {
+  _impl_.participant_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& MessageKey::participant() const {
+  // @@protoc_insertion_point(field_get:proto.MessageKey.participant)
+  return _internal_participant();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MessageKey::set_participant(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MessageKey.participant)
+}
+inline std::string* MessageKey::mutable_participant() {
+  std::string* _s = _internal_mutable_participant();
+  // @@protoc_insertion_point(field_mutable:proto.MessageKey.participant)
+  return _s;
+}
+inline const std::string& MessageKey::_internal_participant() const {
+  return _impl_.participant_.Get();
+}
+inline void MessageKey::_internal_set_participant(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.participant_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MessageKey::_internal_mutable_participant() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.participant_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MessageKey::release_participant() {
+  // @@protoc_insertion_point(field_release:proto.MessageKey.participant)
+  if (!_internal_has_participant()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.participant_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MessageKey::set_allocated_participant(std::string* participant) {
+  if (participant != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.participant)
+}
+
+// -------------------------------------------------------------------
+
+// Money
+
+// optional int64 value = 1;
+inline bool Money::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Money::has_value() const {
+  return _internal_has_value();
+}
+inline void Money::clear_value() {
+  _impl_.value_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t Money::_internal_value() const {
+  return _impl_.value_;
+}
+inline int64_t Money::value() const {
+  // @@protoc_insertion_point(field_get:proto.Money.value)
+  return _internal_value();
+}
+inline void Money::_internal_set_value(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_ = value;
+}
+inline void Money::set_value(int64_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:proto.Money.value)
+}
+
+// optional uint32 offset = 2;
+inline bool Money::_internal_has_offset() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Money::has_offset() const {
+  return _internal_has_offset();
+}
+inline void Money::clear_offset() {
+  _impl_.offset_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t Money::_internal_offset() const {
+  return _impl_.offset_;
+}
+inline uint32_t Money::offset() const {
+  // @@protoc_insertion_point(field_get:proto.Money.offset)
+  return _internal_offset();
+}
+inline void Money::_internal_set_offset(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.offset_ = value;
+}
+inline void Money::set_offset(uint32_t value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:proto.Money.offset)
+}
+
+// optional string currencyCode = 3;
+inline bool Money::_internal_has_currencycode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Money::has_currencycode() const {
+  return _internal_has_currencycode();
+}
+inline void Money::clear_currencycode() {
+  _impl_.currencycode_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Money::currencycode() const {
+  // @@protoc_insertion_point(field_get:proto.Money.currencyCode)
+  return _internal_currencycode();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Money::set_currencycode(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Money.currencyCode)
+}
+inline std::string* Money::mutable_currencycode() {
+  std::string* _s = _internal_mutable_currencycode();
+  // @@protoc_insertion_point(field_mutable:proto.Money.currencyCode)
+  return _s;
+}
+inline const std::string& Money::_internal_currencycode() const {
+  return _impl_.currencycode_.Get();
+}
+inline void Money::_internal_set_currencycode(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.currencycode_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Money::_internal_mutable_currencycode() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Money::release_currencycode() {
+  // @@protoc_insertion_point(field_release:proto.Money.currencyCode)
+  if (!_internal_has_currencycode()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.currencycode_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Money::set_allocated_currencycode(std::string* currencycode) {
+  if (currencycode != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currencycode_.IsDefault()) {
+    _impl_.currencycode_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Money.currencyCode)
+}
+
+// -------------------------------------------------------------------
+
+// MsgOpaqueData_PollOption
+
+// optional string name = 1;
+inline bool MsgOpaqueData_PollOption::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData_PollOption::has_name() const {
+  return _internal_has_name();
+}
+inline void MsgOpaqueData_PollOption::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MsgOpaqueData_PollOption::name() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.PollOption.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData_PollOption::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.PollOption.name)
+}
+inline std::string* MsgOpaqueData_PollOption::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.PollOption.name)
+  return _s;
+}
+inline const std::string& MsgOpaqueData_PollOption::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void MsgOpaqueData_PollOption::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData_PollOption::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData_PollOption::release_name() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.PollOption.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData_PollOption::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.PollOption.name)
+}
+
+// -------------------------------------------------------------------
+
+// MsgOpaqueData
+
+// optional string body = 1;
+inline bool MsgOpaqueData::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_body() const {
+  return _internal_has_body();
+}
+inline void MsgOpaqueData::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MsgOpaqueData::body() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.body)
+}
+inline std::string* MsgOpaqueData::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.body)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void MsgOpaqueData::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_body() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.body)
+}
+
+// optional string caption = 3;
+inline bool MsgOpaqueData::_internal_has_caption() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_caption() const {
+  return _internal_has_caption();
+}
+inline void MsgOpaqueData::clear_caption() {
+  _impl_.caption_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MsgOpaqueData::caption() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.caption)
+  return _internal_caption();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_caption(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.caption)
+}
+inline std::string* MsgOpaqueData::mutable_caption() {
+  std::string* _s = _internal_mutable_caption();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.caption)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_caption() const {
+  return _impl_.caption_.Get();
+}
+inline void MsgOpaqueData::_internal_set_caption(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.caption_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_caption() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.caption_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_caption() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.caption)
+  if (!_internal_has_caption()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.caption_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_caption(std::string* caption) {
+  if (caption != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.caption_.SetAllocated(caption, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.caption_.IsDefault()) {
+    _impl_.caption_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.caption)
+}
+
+// optional double lng = 5;
+inline bool MsgOpaqueData::_internal_has_lng() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_lng() const {
+  return _internal_has_lng();
+}
+inline void MsgOpaqueData::clear_lng() {
+  _impl_.lng_ = 0;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline double MsgOpaqueData::_internal_lng() const {
+  return _impl_.lng_;
+}
+inline double MsgOpaqueData::lng() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lng)
+  return _internal_lng();
+}
+inline void MsgOpaqueData::_internal_set_lng(double value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.lng_ = value;
+}
+inline void MsgOpaqueData::set_lng(double value) {
+  _internal_set_lng(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lng)
+}
+
+// optional bool isLive = 6;
+inline bool MsgOpaqueData::_internal_has_islive() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_islive() const {
+  return _internal_has_islive();
+}
+inline void MsgOpaqueData::clear_islive() {
+  _impl_.islive_ = false;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline bool MsgOpaqueData::_internal_islive() const {
+  return _impl_.islive_;
+}
+inline bool MsgOpaqueData::islive() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.isLive)
+  return _internal_islive();
+}
+inline void MsgOpaqueData::_internal_set_islive(bool value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.islive_ = value;
+}
+inline void MsgOpaqueData::set_islive(bool value) {
+  _internal_set_islive(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.isLive)
+}
+
+// optional double lat = 7;
+inline bool MsgOpaqueData::_internal_has_lat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_lat() const {
+  return _internal_has_lat();
+}
+inline void MsgOpaqueData::clear_lat() {
+  _impl_.lat_ = 0;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline double MsgOpaqueData::_internal_lat() const {
+  return _impl_.lat_;
+}
+inline double MsgOpaqueData::lat() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lat)
+  return _internal_lat();
+}
+inline void MsgOpaqueData::_internal_set_lat(double value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.lat_ = value;
+}
+inline void MsgOpaqueData::set_lat(double value) {
+  _internal_set_lat(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lat)
+}
+
+// optional int32 paymentAmount1000 = 8;
+inline bool MsgOpaqueData::_internal_has_paymentamount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_paymentamount1000() const {
+  return _internal_has_paymentamount1000();
+}
+inline void MsgOpaqueData::clear_paymentamount1000() {
+  _impl_.paymentamount1000_ = 0;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline int32_t MsgOpaqueData::_internal_paymentamount1000() const {
+  return _impl_.paymentamount1000_;
+}
+inline int32_t MsgOpaqueData::paymentamount1000() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentAmount1000)
+  return _internal_paymentamount1000();
+}
+inline void MsgOpaqueData::_internal_set_paymentamount1000(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.paymentamount1000_ = value;
+}
+inline void MsgOpaqueData::set_paymentamount1000(int32_t value) {
+  _internal_set_paymentamount1000(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentAmount1000)
+}
+
+// optional string paymentNoteMsgBody = 9;
+inline bool MsgOpaqueData::_internal_has_paymentnotemsgbody() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_paymentnotemsgbody() const {
+  return _internal_has_paymentnotemsgbody();
+}
+inline void MsgOpaqueData::clear_paymentnotemsgbody() {
+  _impl_.paymentnotemsgbody_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& MsgOpaqueData::paymentnotemsgbody() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentNoteMsgBody)
+  return _internal_paymentnotemsgbody();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.paymentnotemsgbody_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentNoteMsgBody)
+}
+inline std::string* MsgOpaqueData::mutable_paymentnotemsgbody() {
+  std::string* _s = _internal_mutable_paymentnotemsgbody();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.paymentNoteMsgBody)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_paymentnotemsgbody() const {
+  return _impl_.paymentnotemsgbody_.Get();
+}
+inline void MsgOpaqueData::_internal_set_paymentnotemsgbody(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.paymentnotemsgbody_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_paymentnotemsgbody() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.paymentnotemsgbody_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_paymentnotemsgbody() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.paymentNoteMsgBody)
+  if (!_internal_has_paymentnotemsgbody()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.paymentnotemsgbody_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paymentnotemsgbody_.IsDefault()) {
+    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody) {
+  if (paymentnotemsgbody != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.paymentnotemsgbody_.SetAllocated(paymentnotemsgbody, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.paymentnotemsgbody_.IsDefault()) {
+    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.paymentNoteMsgBody)
+}
+
+// optional string canonicalUrl = 10;
+inline bool MsgOpaqueData::_internal_has_canonicalurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_canonicalurl() const {
+  return _internal_has_canonicalurl();
+}
+inline void MsgOpaqueData::clear_canonicalurl() {
+  _impl_.canonicalurl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& MsgOpaqueData::canonicalurl() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.canonicalUrl)
+  return _internal_canonicalurl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_canonicalurl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.canonicalurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.canonicalUrl)
+}
+inline std::string* MsgOpaqueData::mutable_canonicalurl() {
+  std::string* _s = _internal_mutable_canonicalurl();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.canonicalUrl)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_canonicalurl() const {
+  return _impl_.canonicalurl_.Get();
+}
+inline void MsgOpaqueData::_internal_set_canonicalurl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.canonicalurl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_canonicalurl() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.canonicalurl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_canonicalurl() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.canonicalUrl)
+  if (!_internal_has_canonicalurl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.canonicalurl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.canonicalurl_.IsDefault()) {
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_canonicalurl(std::string* canonicalurl) {
+  if (canonicalurl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.canonicalurl_.IsDefault()) {
+    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.canonicalUrl)
+}
+
+// optional string matchedText = 11;
+inline bool MsgOpaqueData::_internal_has_matchedtext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_matchedtext() const {
+  return _internal_has_matchedtext();
+}
+inline void MsgOpaqueData::clear_matchedtext() {
+  _impl_.matchedtext_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& MsgOpaqueData::matchedtext() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.matchedText)
+  return _internal_matchedtext();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_matchedtext(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.matchedtext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.matchedText)
+}
+inline std::string* MsgOpaqueData::mutable_matchedtext() {
+  std::string* _s = _internal_mutable_matchedtext();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.matchedText)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_matchedtext() const {
+  return _impl_.matchedtext_.Get();
+}
+inline void MsgOpaqueData::_internal_set_matchedtext(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.matchedtext_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_matchedtext() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.matchedtext_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_matchedtext() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.matchedText)
+  if (!_internal_has_matchedtext()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.matchedtext_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.matchedtext_.IsDefault()) {
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_matchedtext(std::string* matchedtext) {
+  if (matchedtext != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.matchedtext_.IsDefault()) {
+    _impl_.matchedtext_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.matchedText)
+}
+
+// optional string title = 12;
+inline bool MsgOpaqueData::_internal_has_title() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_title() const {
+  return _internal_has_title();
+}
+inline void MsgOpaqueData::clear_title() {
+  _impl_.title_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& MsgOpaqueData::title() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.title)
+  return _internal_title();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_title(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.title)
+}
+inline std::string* MsgOpaqueData::mutable_title() {
+  std::string* _s = _internal_mutable_title();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.title)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_title() const {
+  return _impl_.title_.Get();
+}
+inline void MsgOpaqueData::_internal_set_title(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.title_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_title() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.title_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_title() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.title)
+  if (!_internal_has_title()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.title_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_title(std::string* title) {
+  if (title != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.title_.IsDefault()) {
+    _impl_.title_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.title)
+}
+
+// optional string description = 13;
+inline bool MsgOpaqueData::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_description() const {
+  return _internal_has_description();
+}
+inline void MsgOpaqueData::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& MsgOpaqueData::description() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.description)
+}
+inline std::string* MsgOpaqueData::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.description)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void MsgOpaqueData::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_description() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.description)
+}
+
+// optional bytes futureproofBuffer = 14;
+inline bool MsgOpaqueData::_internal_has_futureproofbuffer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_futureproofbuffer() const {
+  return _internal_has_futureproofbuffer();
+}
+inline void MsgOpaqueData::clear_futureproofbuffer() {
+  _impl_.futureproofbuffer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& MsgOpaqueData::futureproofbuffer() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.futureproofBuffer)
+  return _internal_futureproofbuffer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_futureproofbuffer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.futureproofbuffer_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.futureproofBuffer)
+}
+inline std::string* MsgOpaqueData::mutable_futureproofbuffer() {
+  std::string* _s = _internal_mutable_futureproofbuffer();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.futureproofBuffer)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_futureproofbuffer() const {
+  return _impl_.futureproofbuffer_.Get();
+}
+inline void MsgOpaqueData::_internal_set_futureproofbuffer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.futureproofbuffer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_futureproofbuffer() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.futureproofbuffer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_futureproofbuffer() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.futureproofBuffer)
+  if (!_internal_has_futureproofbuffer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.futureproofbuffer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.futureproofbuffer_.IsDefault()) {
+    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_futureproofbuffer(std::string* futureproofbuffer) {
+  if (futureproofbuffer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.futureproofbuffer_.SetAllocated(futureproofbuffer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.futureproofbuffer_.IsDefault()) {
+    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.futureproofBuffer)
+}
+
+// optional string clientUrl = 15;
+inline bool MsgOpaqueData::_internal_has_clienturl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_clienturl() const {
+  return _internal_has_clienturl();
+}
+inline void MsgOpaqueData::clear_clienturl() {
+  _impl_.clienturl_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& MsgOpaqueData::clienturl() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.clientUrl)
+  return _internal_clienturl();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_clienturl(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.clienturl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.clientUrl)
+}
+inline std::string* MsgOpaqueData::mutable_clienturl() {
+  std::string* _s = _internal_mutable_clienturl();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.clientUrl)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_clienturl() const {
+  return _impl_.clienturl_.Get();
+}
+inline void MsgOpaqueData::_internal_set_clienturl(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.clienturl_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_clienturl() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.clienturl_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_clienturl() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.clientUrl)
+  if (!_internal_has_clienturl()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.clienturl_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.clienturl_.IsDefault()) {
+    _impl_.clienturl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_clienturl(std::string* clienturl) {
+  if (clienturl != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.clienturl_.SetAllocated(clienturl, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.clienturl_.IsDefault()) {
+    _impl_.clienturl_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.clientUrl)
+}
+
+// optional string loc = 16;
+inline bool MsgOpaqueData::_internal_has_loc() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_loc() const {
+  return _internal_has_loc();
+}
+inline void MsgOpaqueData::clear_loc() {
+  _impl_.loc_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& MsgOpaqueData::loc() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.loc)
+  return _internal_loc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_loc(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.loc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.loc)
+}
+inline std::string* MsgOpaqueData::mutable_loc() {
+  std::string* _s = _internal_mutable_loc();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.loc)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_loc() const {
+  return _impl_.loc_.Get();
+}
+inline void MsgOpaqueData::_internal_set_loc(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.loc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_loc() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.loc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_loc() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.loc)
+  if (!_internal_has_loc()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.loc_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.loc_.IsDefault()) {
+    _impl_.loc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_loc(std::string* loc) {
+  if (loc != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.loc_.SetAllocated(loc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.loc_.IsDefault()) {
+    _impl_.loc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.loc)
+}
+
+// optional string pollName = 17;
+inline bool MsgOpaqueData::_internal_has_pollname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_pollname() const {
+  return _internal_has_pollname();
+}
+inline void MsgOpaqueData::clear_pollname() {
+  _impl_.pollname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const std::string& MsgOpaqueData::pollname() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollName)
+  return _internal_pollname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_pollname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000400u;
+ _impl_.pollname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollName)
+}
+inline std::string* MsgOpaqueData::mutable_pollname() {
+  std::string* _s = _internal_mutable_pollname();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollName)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_pollname() const {
+  return _impl_.pollname_.Get();
+}
+inline void MsgOpaqueData::_internal_set_pollname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.pollname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_pollname() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  return _impl_.pollname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_pollname() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollName)
+  if (!_internal_has_pollname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  auto* p = _impl_.pollname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pollname_.IsDefault()) {
+    _impl_.pollname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_pollname(std::string* pollname) {
+  if (pollname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.pollname_.SetAllocated(pollname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pollname_.IsDefault()) {
+    _impl_.pollname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollName)
+}
+
+// repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
+inline int MsgOpaqueData::_internal_polloptions_size() const {
+  return _impl_.polloptions_.size();
+}
+inline int MsgOpaqueData::polloptions_size() const {
+  return _internal_polloptions_size();
+}
+inline void MsgOpaqueData::clear_polloptions() {
+  _impl_.polloptions_.Clear();
+}
+inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::mutable_polloptions(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollOptions)
+  return _impl_.polloptions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >*
+MsgOpaqueData::mutable_polloptions() {
+  // @@protoc_insertion_point(field_mutable_list:proto.MsgOpaqueData.pollOptions)
+  return &_impl_.polloptions_;
+}
+inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::_internal_polloptions(int index) const {
+  return _impl_.polloptions_.Get(index);
+}
+inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::polloptions(int index) const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollOptions)
+  return _internal_polloptions(index);
+}
+inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::_internal_add_polloptions() {
+  return _impl_.polloptions_.Add();
+}
+inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::add_polloptions() {
+  ::proto::MsgOpaqueData_PollOption* _add = _internal_add_polloptions();
+  // @@protoc_insertion_point(field_add:proto.MsgOpaqueData.pollOptions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >&
+MsgOpaqueData::polloptions() const {
+  // @@protoc_insertion_point(field_list:proto.MsgOpaqueData.pollOptions)
+  return _impl_.polloptions_;
+}
+
+// optional uint32 pollSelectableOptionsCount = 20;
+inline bool MsgOpaqueData::_internal_has_pollselectableoptionscount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_pollselectableoptionscount() const {
+  return _internal_has_pollselectableoptionscount();
+}
+inline void MsgOpaqueData::clear_pollselectableoptionscount() {
+  _impl_.pollselectableoptionscount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline uint32_t MsgOpaqueData::_internal_pollselectableoptionscount() const {
+  return _impl_.pollselectableoptionscount_;
+}
+inline uint32_t MsgOpaqueData::pollselectableoptionscount() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollSelectableOptionsCount)
+  return _internal_pollselectableoptionscount();
+}
+inline void MsgOpaqueData::_internal_set_pollselectableoptionscount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.pollselectableoptionscount_ = value;
+}
+inline void MsgOpaqueData::set_pollselectableoptionscount(uint32_t value) {
+  _internal_set_pollselectableoptionscount(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollSelectableOptionsCount)
+}
+
+// optional bytes messageSecret = 21;
+inline bool MsgOpaqueData::_internal_has_messagesecret() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_messagesecret() const {
+  return _internal_has_messagesecret();
+}
+inline void MsgOpaqueData::clear_messagesecret() {
+  _impl_.messagesecret_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const std::string& MsgOpaqueData::messagesecret() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.messageSecret)
+  return _internal_messagesecret();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_messagesecret(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000800u;
+ _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.messageSecret)
+}
+inline std::string* MsgOpaqueData::mutable_messagesecret() {
+  std::string* _s = _internal_mutable_messagesecret();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.messageSecret)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_messagesecret() const {
+  return _impl_.messagesecret_.Get();
+}
+inline void MsgOpaqueData::_internal_set_messagesecret(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_messagesecret() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_messagesecret() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.messageSecret)
+  if (!_internal_has_messagesecret()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  auto* p = _impl_.messagesecret_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_messagesecret(std::string* messagesecret) {
+  if (messagesecret != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.messageSecret)
+}
+
+// optional int64 senderTimestampMs = 22;
+inline bool MsgOpaqueData::_internal_has_sendertimestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_sendertimestampms() const {
+  return _internal_has_sendertimestampms();
+}
+inline void MsgOpaqueData::clear_sendertimestampms() {
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline int64_t MsgOpaqueData::_internal_sendertimestampms() const {
+  return _impl_.sendertimestampms_;
+}
+inline int64_t MsgOpaqueData::sendertimestampms() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.senderTimestampMs)
+  return _internal_sendertimestampms();
+}
+inline void MsgOpaqueData::_internal_set_sendertimestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.sendertimestampms_ = value;
+}
+inline void MsgOpaqueData::set_sendertimestampms(int64_t value) {
+  _internal_set_sendertimestampms(value);
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.senderTimestampMs)
+}
+
+// optional string pollUpdateParentKey = 23;
+inline bool MsgOpaqueData::_internal_has_pollupdateparentkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool MsgOpaqueData::has_pollupdateparentkey() const {
+  return _internal_has_pollupdateparentkey();
+}
+inline void MsgOpaqueData::clear_pollupdateparentkey() {
+  _impl_.pollupdateparentkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const std::string& MsgOpaqueData::pollupdateparentkey() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollUpdateParentKey)
+  return _internal_pollupdateparentkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgOpaqueData::set_pollupdateparentkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00001000u;
+ _impl_.pollupdateparentkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollUpdateParentKey)
+}
+inline std::string* MsgOpaqueData::mutable_pollupdateparentkey() {
+  std::string* _s = _internal_mutable_pollupdateparentkey();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollUpdateParentKey)
+  return _s;
+}
+inline const std::string& MsgOpaqueData::_internal_pollupdateparentkey() const {
+  return _impl_.pollupdateparentkey_.Get();
+}
+inline void MsgOpaqueData::_internal_set_pollupdateparentkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.pollupdateparentkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::_internal_mutable_pollupdateparentkey() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  return _impl_.pollupdateparentkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MsgOpaqueData::release_pollupdateparentkey() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollUpdateParentKey)
+  if (!_internal_has_pollupdateparentkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  auto* p = _impl_.pollupdateparentkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pollupdateparentkey_.IsDefault()) {
+    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MsgOpaqueData::set_allocated_pollupdateparentkey(std::string* pollupdateparentkey) {
+  if (pollupdateparentkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.pollupdateparentkey_.SetAllocated(pollupdateparentkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pollupdateparentkey_.IsDefault()) {
+    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollUpdateParentKey)
+}
+
+// optional .proto.PollEncValue encPollVote = 24;
+inline bool MsgOpaqueData::_internal_has_encpollvote() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.encpollvote_ != nullptr);
+  return value;
+}
+inline bool MsgOpaqueData::has_encpollvote() const {
+  return _internal_has_encpollvote();
+}
+inline void MsgOpaqueData::clear_encpollvote() {
+  if (_impl_.encpollvote_ != nullptr) _impl_.encpollvote_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::PollEncValue& MsgOpaqueData::_internal_encpollvote() const {
+  const ::proto::PollEncValue* p = _impl_.encpollvote_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PollEncValue&>(
+      ::proto::_PollEncValue_default_instance_);
+}
+inline const ::proto::PollEncValue& MsgOpaqueData::encpollvote() const {
+  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.encPollVote)
+  return _internal_encpollvote();
+}
+inline void MsgOpaqueData::unsafe_arena_set_allocated_encpollvote(
+    ::proto::PollEncValue* encpollvote) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.encpollvote_);
+  }
+  _impl_.encpollvote_ = encpollvote;
+  if (encpollvote) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgOpaqueData.encPollVote)
+}
+inline ::proto::PollEncValue* MsgOpaqueData::release_encpollvote() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::PollEncValue* temp = _impl_.encpollvote_;
+  _impl_.encpollvote_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PollEncValue* MsgOpaqueData::unsafe_arena_release_encpollvote() {
+  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.encPollVote)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::PollEncValue* temp = _impl_.encpollvote_;
+  _impl_.encpollvote_ = nullptr;
+  return temp;
+}
+inline ::proto::PollEncValue* MsgOpaqueData::_internal_mutable_encpollvote() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.encpollvote_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PollEncValue>(GetArenaForAllocation());
+    _impl_.encpollvote_ = p;
+  }
+  return _impl_.encpollvote_;
+}
+inline ::proto::PollEncValue* MsgOpaqueData::mutable_encpollvote() {
+  ::proto::PollEncValue* _msg = _internal_mutable_encpollvote();
+  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.encPollVote)
+  return _msg;
+}
+inline void MsgOpaqueData::set_allocated_encpollvote(::proto::PollEncValue* encpollvote) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.encpollvote_;
+  }
+  if (encpollvote) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(encpollvote);
+    if (message_arena != submessage_arena) {
+      encpollvote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encpollvote, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.encpollvote_ = encpollvote;
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.encPollVote)
+}
+
+// -------------------------------------------------------------------
+
+// MsgRowOpaqueData
+
+// optional .proto.MsgOpaqueData currentMsg = 1;
+inline bool MsgRowOpaqueData::_internal_has_currentmsg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.currentmsg_ != nullptr);
+  return value;
+}
+inline bool MsgRowOpaqueData::has_currentmsg() const {
+  return _internal_has_currentmsg();
+}
+inline void MsgRowOpaqueData::clear_currentmsg() {
+  if (_impl_.currentmsg_ != nullptr) _impl_.currentmsg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_currentmsg() const {
+  const ::proto::MsgOpaqueData* p = _impl_.currentmsg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MsgOpaqueData&>(
+      ::proto::_MsgOpaqueData_default_instance_);
+}
+inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::currentmsg() const {
+  // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.currentMsg)
+  return _internal_currentmsg();
+}
+inline void MsgRowOpaqueData::unsafe_arena_set_allocated_currentmsg(
+    ::proto::MsgOpaqueData* currentmsg) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentmsg_);
+  }
+  _impl_.currentmsg_ = currentmsg;
+  if (currentmsg) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.currentMsg)
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_currentmsg() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MsgOpaqueData* temp = _impl_.currentmsg_;
+  _impl_.currentmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_currentmsg() {
+  // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.currentMsg)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MsgOpaqueData* temp = _impl_.currentmsg_;
+  _impl_.currentmsg_ = nullptr;
+  return temp;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_currentmsg() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.currentmsg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation());
+    _impl_.currentmsg_ = p;
+  }
+  return _impl_.currentmsg_;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_currentmsg() {
+  ::proto::MsgOpaqueData* _msg = _internal_mutable_currentmsg();
+  // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.currentMsg)
+  return _msg;
+}
+inline void MsgRowOpaqueData::set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.currentmsg_;
+  }
+  if (currentmsg) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentmsg);
+    if (message_arena != submessage_arena) {
+      currentmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, currentmsg, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.currentmsg_ = currentmsg;
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.currentMsg)
+}
+
+// optional .proto.MsgOpaqueData quotedMsg = 2;
+inline bool MsgRowOpaqueData::_internal_has_quotedmsg() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quotedmsg_ != nullptr);
+  return value;
+}
+inline bool MsgRowOpaqueData::has_quotedmsg() const {
+  return _internal_has_quotedmsg();
+}
+inline void MsgRowOpaqueData::clear_quotedmsg() {
+  if (_impl_.quotedmsg_ != nullptr) _impl_.quotedmsg_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_quotedmsg() const {
+  const ::proto::MsgOpaqueData* p = _impl_.quotedmsg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MsgOpaqueData&>(
+      ::proto::_MsgOpaqueData_default_instance_);
+}
+inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::quotedmsg() const {
+  // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.quotedMsg)
+  return _internal_quotedmsg();
+}
+inline void MsgRowOpaqueData::unsafe_arena_set_allocated_quotedmsg(
+    ::proto::MsgOpaqueData* quotedmsg) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmsg_);
+  }
+  _impl_.quotedmsg_ = quotedmsg;
+  if (quotedmsg) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.quotedMsg)
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_quotedmsg() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_;
+  _impl_.quotedmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_quotedmsg() {
+  // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.quotedMsg)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_;
+  _impl_.quotedmsg_ = nullptr;
+  return temp;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_quotedmsg() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.quotedmsg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation());
+    _impl_.quotedmsg_ = p;
+  }
+  return _impl_.quotedmsg_;
+}
+inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_quotedmsg() {
+  ::proto::MsgOpaqueData* _msg = _internal_mutable_quotedmsg();
+  // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.quotedMsg)
+  return _msg;
+}
+inline void MsgRowOpaqueData::set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quotedmsg_;
+  }
+  if (quotedmsg) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmsg);
+    if (message_arena != submessage_arena) {
+      quotedmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quotedmsg, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.quotedmsg_ = quotedmsg;
+  // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.quotedMsg)
+}
+
+// -------------------------------------------------------------------
+
+// NoiseCertificate_Details
+
+// optional uint32 serial = 1;
+inline bool NoiseCertificate_Details::_internal_has_serial() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool NoiseCertificate_Details::has_serial() const {
+  return _internal_has_serial();
+}
+inline void NoiseCertificate_Details::clear_serial() {
+  _impl_.serial_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t NoiseCertificate_Details::_internal_serial() const {
+  return _impl_.serial_;
+}
+inline uint32_t NoiseCertificate_Details::serial() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.serial)
+  return _internal_serial();
+}
+inline void NoiseCertificate_Details::_internal_set_serial(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.serial_ = value;
+}
+inline void NoiseCertificate_Details::set_serial(uint32_t value) {
+  _internal_set_serial(value);
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.serial)
+}
+
+// optional string issuer = 2;
+inline bool NoiseCertificate_Details::_internal_has_issuer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool NoiseCertificate_Details::has_issuer() const {
+  return _internal_has_issuer();
+}
+inline void NoiseCertificate_Details::clear_issuer() {
+  _impl_.issuer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NoiseCertificate_Details::issuer() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.issuer)
+  return _internal_issuer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NoiseCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.issuer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.issuer)
+}
+inline std::string* NoiseCertificate_Details::mutable_issuer() {
+  std::string* _s = _internal_mutable_issuer();
+  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.issuer)
+  return _s;
+}
+inline const std::string& NoiseCertificate_Details::_internal_issuer() const {
+  return _impl_.issuer_.Get();
+}
+inline void NoiseCertificate_Details::_internal_set_issuer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.issuer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::_internal_mutable_issuer() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.issuer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::release_issuer() {
+  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.issuer)
+  if (!_internal_has_issuer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.issuer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.issuer_.IsDefault()) {
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NoiseCertificate_Details::set_allocated_issuer(std::string* issuer) {
+  if (issuer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.issuer_.IsDefault()) {
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.issuer)
+}
+
+// optional uint64 expires = 3;
+inline bool NoiseCertificate_Details::_internal_has_expires() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool NoiseCertificate_Details::has_expires() const {
+  return _internal_has_expires();
+}
+inline void NoiseCertificate_Details::clear_expires() {
+  _impl_.expires_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t NoiseCertificate_Details::_internal_expires() const {
+  return _impl_.expires_;
+}
+inline uint64_t NoiseCertificate_Details::expires() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.expires)
+  return _internal_expires();
+}
+inline void NoiseCertificate_Details::_internal_set_expires(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.expires_ = value;
+}
+inline void NoiseCertificate_Details::set_expires(uint64_t value) {
+  _internal_set_expires(value);
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.expires)
+}
+
+// optional string subject = 4;
+inline bool NoiseCertificate_Details::_internal_has_subject() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool NoiseCertificate_Details::has_subject() const {
+  return _internal_has_subject();
+}
+inline void NoiseCertificate_Details::clear_subject() {
+  _impl_.subject_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& NoiseCertificate_Details::subject() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.subject)
+  return _internal_subject();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NoiseCertificate_Details::set_subject(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.subject_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.subject)
+}
+inline std::string* NoiseCertificate_Details::mutable_subject() {
+  std::string* _s = _internal_mutable_subject();
+  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.subject)
+  return _s;
+}
+inline const std::string& NoiseCertificate_Details::_internal_subject() const {
+  return _impl_.subject_.Get();
+}
+inline void NoiseCertificate_Details::_internal_set_subject(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.subject_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::_internal_mutable_subject() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.subject_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::release_subject() {
+  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.subject)
+  if (!_internal_has_subject()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.subject_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.subject_.IsDefault()) {
+    _impl_.subject_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NoiseCertificate_Details::set_allocated_subject(std::string* subject) {
+  if (subject != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.subject_.SetAllocated(subject, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.subject_.IsDefault()) {
+    _impl_.subject_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.subject)
+}
+
+// optional bytes key = 5;
+inline bool NoiseCertificate_Details::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool NoiseCertificate_Details::has_key() const {
+  return _internal_has_key();
+}
+inline void NoiseCertificate_Details::clear_key() {
+  _impl_.key_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& NoiseCertificate_Details::key() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.key)
+}
+inline std::string* NoiseCertificate_Details::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.key)
+  return _s;
+}
+inline const std::string& NoiseCertificate_Details::_internal_key() const {
+  return _impl_.key_.Get();
+}
+inline void NoiseCertificate_Details::_internal_set_key(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate_Details::release_key() {
+  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.key_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NoiseCertificate_Details::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.key)
+}
+
+// -------------------------------------------------------------------
+
+// NoiseCertificate
+
+// optional bytes details = 1;
+inline bool NoiseCertificate::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool NoiseCertificate::has_details() const {
+  return _internal_has_details();
+}
+inline void NoiseCertificate::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NoiseCertificate::details() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.details)
+}
+inline std::string* NoiseCertificate::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.details)
+  return _s;
+}
+inline const std::string& NoiseCertificate::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void NoiseCertificate::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate::release_details() {
+  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NoiseCertificate::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.details)
+}
+
+// optional bytes signature = 2;
+inline bool NoiseCertificate::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool NoiseCertificate::has_signature() const {
+  return _internal_has_signature();
+}
+inline void NoiseCertificate::clear_signature() {
+  _impl_.signature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& NoiseCertificate::signature() const {
+  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.signature)
+}
+inline std::string* NoiseCertificate::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.signature)
+  return _s;
+}
+inline const std::string& NoiseCertificate::_internal_signature() const {
+  return _impl_.signature_.Get();
+}
+inline void NoiseCertificate::_internal_set_signature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.signature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.signature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NoiseCertificate::release_signature() {
+  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.signature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NoiseCertificate::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.signature)
+}
+
+// -------------------------------------------------------------------
+
+// NotificationMessageInfo
+
+// optional .proto.MessageKey key = 1;
+inline bool NotificationMessageInfo::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool NotificationMessageInfo::has_key() const {
+  return _internal_has_key();
+}
+inline void NotificationMessageInfo::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::MessageKey& NotificationMessageInfo::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& NotificationMessageInfo::key() const {
+  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.key)
+  return _internal_key();
+}
+inline void NotificationMessageInfo::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.key)
+}
+inline ::proto::MessageKey* NotificationMessageInfo::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* NotificationMessageInfo::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.key)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* NotificationMessageInfo::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* NotificationMessageInfo::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.key)
+  return _msg;
+}
+inline void NotificationMessageInfo::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.key)
+}
+
+// optional .proto.Message message = 2;
+inline bool NotificationMessageInfo::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
+  return value;
+}
+inline bool NotificationMessageInfo::has_message() const {
+  return _internal_has_message();
+}
+inline void NotificationMessageInfo::clear_message() {
+  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::Message& NotificationMessageInfo::_internal_message() const {
+  const ::proto::Message* p = _impl_.message_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& NotificationMessageInfo::message() const {
+  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.message)
+  return _internal_message();
+}
+inline void NotificationMessageInfo::unsafe_arena_set_allocated_message(
+    ::proto::Message* message) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
+  }
+  _impl_.message_ = message;
+  if (message) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.message)
+}
+inline ::proto::Message* NotificationMessageInfo::release_message() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* NotificationMessageInfo::unsafe_arena_release_message() {
+  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.message)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* NotificationMessageInfo::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.message_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.message_ = p;
+  }
+  return _impl_.message_;
+}
+inline ::proto::Message* NotificationMessageInfo::mutable_message() {
+  ::proto::Message* _msg = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.message)
+  return _msg;
+}
+inline void NotificationMessageInfo::set_allocated_message(::proto::Message* message) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.message_;
+  }
+  if (message) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
+    if (message_arena != submessage_arena) {
+      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, message, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.message_ = message;
+  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.message)
+}
+
+// optional uint64 messageTimestamp = 3;
+inline bool NotificationMessageInfo::_internal_has_messagetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool NotificationMessageInfo::has_messagetimestamp() const {
+  return _internal_has_messagetimestamp();
+}
+inline void NotificationMessageInfo::clear_messagetimestamp() {
+  _impl_.messagetimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t NotificationMessageInfo::_internal_messagetimestamp() const {
+  return _impl_.messagetimestamp_;
+}
+inline uint64_t NotificationMessageInfo::messagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.messageTimestamp)
+  return _internal_messagetimestamp();
+}
+inline void NotificationMessageInfo::_internal_set_messagetimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.messagetimestamp_ = value;
+}
+inline void NotificationMessageInfo::set_messagetimestamp(uint64_t value) {
+  _internal_set_messagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.messageTimestamp)
+}
+
+// optional string participant = 4;
+inline bool NotificationMessageInfo::_internal_has_participant() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool NotificationMessageInfo::has_participant() const {
+  return _internal_has_participant();
+}
+inline void NotificationMessageInfo::clear_participant() {
+  _impl_.participant_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NotificationMessageInfo::participant() const {
+  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.participant)
+  return _internal_participant();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NotificationMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.participant)
+}
+inline std::string* NotificationMessageInfo::mutable_participant() {
+  std::string* _s = _internal_mutable_participant();
+  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.participant)
+  return _s;
+}
+inline const std::string& NotificationMessageInfo::_internal_participant() const {
+  return _impl_.participant_.Get();
+}
+inline void NotificationMessageInfo::_internal_set_participant(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.participant_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NotificationMessageInfo::_internal_mutable_participant() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.participant_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NotificationMessageInfo::release_participant() {
+  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.participant)
+  if (!_internal_has_participant()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.participant_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NotificationMessageInfo::set_allocated_participant(std::string* participant) {
+  if (participant != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.participant)
+}
+
+// -------------------------------------------------------------------
+
+// PastParticipant
+
+// required string userJid = 1;
+inline bool PastParticipant::_internal_has_userjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PastParticipant::has_userjid() const {
+  return _internal_has_userjid();
+}
+inline void PastParticipant::clear_userjid() {
+  _impl_.userjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PastParticipant::userjid() const {
+  // @@protoc_insertion_point(field_get:proto.PastParticipant.userJid)
+  return _internal_userjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PastParticipant::set_userjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PastParticipant.userJid)
+}
+inline std::string* PastParticipant::mutable_userjid() {
+  std::string* _s = _internal_mutable_userjid();
+  // @@protoc_insertion_point(field_mutable:proto.PastParticipant.userJid)
+  return _s;
+}
+inline const std::string& PastParticipant::_internal_userjid() const {
+  return _impl_.userjid_.Get();
+}
+inline void PastParticipant::_internal_set_userjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.userjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PastParticipant::_internal_mutable_userjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.userjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PastParticipant::release_userjid() {
+  // @@protoc_insertion_point(field_release:proto.PastParticipant.userJid)
+  if (!_internal_has_userjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.userjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PastParticipant::set_allocated_userjid(std::string* userjid) {
+  if (userjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PastParticipant.userJid)
+}
+
+// required .proto.PastParticipant.LeaveReason leaveReason = 2;
+inline bool PastParticipant::_internal_has_leavereason() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PastParticipant::has_leavereason() const {
+  return _internal_has_leavereason();
+}
+inline void PastParticipant::clear_leavereason() {
+  _impl_.leavereason_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::PastParticipant_LeaveReason PastParticipant::_internal_leavereason() const {
+  return static_cast< ::proto::PastParticipant_LeaveReason >(_impl_.leavereason_);
+}
+inline ::proto::PastParticipant_LeaveReason PastParticipant::leavereason() const {
+  // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveReason)
+  return _internal_leavereason();
+}
+inline void PastParticipant::_internal_set_leavereason(::proto::PastParticipant_LeaveReason value) {
+  assert(::proto::PastParticipant_LeaveReason_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.leavereason_ = value;
+}
+inline void PastParticipant::set_leavereason(::proto::PastParticipant_LeaveReason value) {
+  _internal_set_leavereason(value);
+  // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveReason)
+}
+
+// required uint64 leaveTs = 3;
+inline bool PastParticipant::_internal_has_leavets() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PastParticipant::has_leavets() const {
+  return _internal_has_leavets();
+}
+inline void PastParticipant::clear_leavets() {
+  _impl_.leavets_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t PastParticipant::_internal_leavets() const {
+  return _impl_.leavets_;
+}
+inline uint64_t PastParticipant::leavets() const {
+  // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveTs)
+  return _internal_leavets();
+}
+inline void PastParticipant::_internal_set_leavets(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.leavets_ = value;
+}
+inline void PastParticipant::set_leavets(uint64_t value) {
+  _internal_set_leavets(value);
+  // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveTs)
+}
+
+// -------------------------------------------------------------------
+
+// PastParticipants
+
+// required string groupJid = 1;
+inline bool PastParticipants::_internal_has_groupjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PastParticipants::has_groupjid() const {
+  return _internal_has_groupjid();
+}
+inline void PastParticipants::clear_groupjid() {
+  _impl_.groupjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PastParticipants::groupjid() const {
+  // @@protoc_insertion_point(field_get:proto.PastParticipants.groupJid)
+  return _internal_groupjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PastParticipants::set_groupjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.groupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PastParticipants.groupJid)
+}
+inline std::string* PastParticipants::mutable_groupjid() {
+  std::string* _s = _internal_mutable_groupjid();
+  // @@protoc_insertion_point(field_mutable:proto.PastParticipants.groupJid)
+  return _s;
+}
+inline const std::string& PastParticipants::_internal_groupjid() const {
+  return _impl_.groupjid_.Get();
+}
+inline void PastParticipants::_internal_set_groupjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.groupjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PastParticipants::_internal_mutable_groupjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.groupjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PastParticipants::release_groupjid() {
+  // @@protoc_insertion_point(field_release:proto.PastParticipants.groupJid)
+  if (!_internal_has_groupjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.groupjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupjid_.IsDefault()) {
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PastParticipants::set_allocated_groupjid(std::string* groupjid) {
+  if (groupjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupjid_.IsDefault()) {
+    _impl_.groupjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PastParticipants.groupJid)
+}
+
+// repeated .proto.PastParticipant pastParticipants = 2;
+inline int PastParticipants::_internal_pastparticipants_size() const {
+  return _impl_.pastparticipants_.size();
+}
+inline int PastParticipants::pastparticipants_size() const {
+  return _internal_pastparticipants_size();
+}
+inline void PastParticipants::clear_pastparticipants() {
+  _impl_.pastparticipants_.Clear();
+}
+inline ::proto::PastParticipant* PastParticipants::mutable_pastparticipants(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.PastParticipants.pastParticipants)
+  return _impl_.pastparticipants_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >*
+PastParticipants::mutable_pastparticipants() {
+  // @@protoc_insertion_point(field_mutable_list:proto.PastParticipants.pastParticipants)
+  return &_impl_.pastparticipants_;
+}
+inline const ::proto::PastParticipant& PastParticipants::_internal_pastparticipants(int index) const {
+  return _impl_.pastparticipants_.Get(index);
+}
+inline const ::proto::PastParticipant& PastParticipants::pastparticipants(int index) const {
+  // @@protoc_insertion_point(field_get:proto.PastParticipants.pastParticipants)
+  return _internal_pastparticipants(index);
+}
+inline ::proto::PastParticipant* PastParticipants::_internal_add_pastparticipants() {
+  return _impl_.pastparticipants_.Add();
+}
+inline ::proto::PastParticipant* PastParticipants::add_pastparticipants() {
+  ::proto::PastParticipant* _add = _internal_add_pastparticipants();
+  // @@protoc_insertion_point(field_add:proto.PastParticipants.pastParticipants)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >&
+PastParticipants::pastparticipants() const {
+  // @@protoc_insertion_point(field_list:proto.PastParticipants.pastParticipants)
+  return _impl_.pastparticipants_;
+}
+
+// -------------------------------------------------------------------
+
+// PaymentBackground_MediaData
+
+// optional bytes mediaKey = 1;
+inline bool PaymentBackground_MediaData::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PaymentBackground_MediaData::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void PaymentBackground_MediaData::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PaymentBackground_MediaData::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground_MediaData::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKey)
+}
+inline std::string* PaymentBackground_MediaData::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.mediaKey)
+  return _s;
+}
+inline const std::string& PaymentBackground_MediaData::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void PaymentBackground_MediaData::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground_MediaData::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.mediaKey)
+}
+
+// optional int64 mediaKeyTimestamp = 2;
+inline bool PaymentBackground_MediaData::_internal_has_mediakeytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PaymentBackground_MediaData::has_mediakeytimestamp() const {
+  return _internal_has_mediakeytimestamp();
+}
+inline void PaymentBackground_MediaData::clear_mediakeytimestamp() {
+  _impl_.mediakeytimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int64_t PaymentBackground_MediaData::_internal_mediakeytimestamp() const {
+  return _impl_.mediakeytimestamp_;
+}
+inline int64_t PaymentBackground_MediaData::mediakeytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKeyTimestamp)
+  return _internal_mediakeytimestamp();
+}
+inline void PaymentBackground_MediaData::_internal_set_mediakeytimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.mediakeytimestamp_ = value;
+}
+inline void PaymentBackground_MediaData::set_mediakeytimestamp(int64_t value) {
+  _internal_set_mediakeytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKeyTimestamp)
+}
+
+// optional bytes fileSha256 = 3;
+inline bool PaymentBackground_MediaData::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PaymentBackground_MediaData::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void PaymentBackground_MediaData::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PaymentBackground_MediaData::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground_MediaData::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileSha256)
+}
+inline std::string* PaymentBackground_MediaData::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileSha256)
+  return _s;
+}
+inline const std::string& PaymentBackground_MediaData::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void PaymentBackground_MediaData::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground_MediaData::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileSha256)
+}
+
+// optional bytes fileEncSha256 = 4;
+inline bool PaymentBackground_MediaData::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PaymentBackground_MediaData::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void PaymentBackground_MediaData::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PaymentBackground_MediaData::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground_MediaData::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileEncSha256)
+}
+inline std::string* PaymentBackground_MediaData::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileEncSha256)
+  return _s;
+}
+inline const std::string& PaymentBackground_MediaData::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void PaymentBackground_MediaData::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground_MediaData::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileEncSha256)
+}
+
+// optional string directPath = 5;
+inline bool PaymentBackground_MediaData::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PaymentBackground_MediaData::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void PaymentBackground_MediaData::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PaymentBackground_MediaData::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground_MediaData::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.directPath)
+}
+inline std::string* PaymentBackground_MediaData::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.directPath)
+  return _s;
+}
+inline const std::string& PaymentBackground_MediaData::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void PaymentBackground_MediaData::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground_MediaData::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground_MediaData::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.directPath)
+}
+
+// -------------------------------------------------------------------
+
+// PaymentBackground
+
+// optional string id = 1;
+inline bool PaymentBackground::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_id() const {
+  return _internal_has_id();
+}
+inline void PaymentBackground::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PaymentBackground::id() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.id)
+}
+inline std::string* PaymentBackground::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.id)
+  return _s;
+}
+inline const std::string& PaymentBackground::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void PaymentBackground::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground::release_id() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.id)
+}
+
+// optional uint64 fileLength = 2;
+inline bool PaymentBackground::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void PaymentBackground::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t PaymentBackground::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t PaymentBackground::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.fileLength)
+  return _internal_filelength();
+}
+inline void PaymentBackground::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.filelength_ = value;
+}
+inline void PaymentBackground::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.fileLength)
+}
+
+// optional uint32 width = 3;
+inline bool PaymentBackground::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_width() const {
+  return _internal_has_width();
+}
+inline void PaymentBackground::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t PaymentBackground::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t PaymentBackground::width() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.width)
+  return _internal_width();
+}
+inline void PaymentBackground::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.width_ = value;
+}
+inline void PaymentBackground::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.width)
+}
+
+// optional uint32 height = 4;
+inline bool PaymentBackground::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_height() const {
+  return _internal_has_height();
+}
+inline void PaymentBackground::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint32_t PaymentBackground::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t PaymentBackground::height() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.height)
+  return _internal_height();
+}
+inline void PaymentBackground::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.height_ = value;
+}
+inline void PaymentBackground::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.height)
+}
+
+// optional string mimetype = 5;
+inline bool PaymentBackground::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void PaymentBackground::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PaymentBackground::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentBackground::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.mimetype)
+}
+inline std::string* PaymentBackground::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mimetype)
+  return _s;
+}
+inline const std::string& PaymentBackground::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void PaymentBackground::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentBackground::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentBackground::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentBackground::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mimetype)
+}
+
+// optional fixed32 placeholderArgb = 6;
+inline bool PaymentBackground::_internal_has_placeholderargb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_placeholderargb() const {
+  return _internal_has_placeholderargb();
+}
+inline void PaymentBackground::clear_placeholderargb() {
+  _impl_.placeholderargb_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint32_t PaymentBackground::_internal_placeholderargb() const {
+  return _impl_.placeholderargb_;
+}
+inline uint32_t PaymentBackground::placeholderargb() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.placeholderArgb)
+  return _internal_placeholderargb();
+}
+inline void PaymentBackground::_internal_set_placeholderargb(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.placeholderargb_ = value;
+}
+inline void PaymentBackground::set_placeholderargb(uint32_t value) {
+  _internal_set_placeholderargb(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.placeholderArgb)
+}
+
+// optional fixed32 textArgb = 7;
+inline bool PaymentBackground::_internal_has_textargb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_textargb() const {
+  return _internal_has_textargb();
+}
+inline void PaymentBackground::clear_textargb() {
+  _impl_.textargb_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint32_t PaymentBackground::_internal_textargb() const {
+  return _impl_.textargb_;
+}
+inline uint32_t PaymentBackground::textargb() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.textArgb)
+  return _internal_textargb();
+}
+inline void PaymentBackground::_internal_set_textargb(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.textargb_ = value;
+}
+inline void PaymentBackground::set_textargb(uint32_t value) {
+  _internal_set_textargb(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.textArgb)
+}
+
+// optional fixed32 subtextArgb = 8;
+inline bool PaymentBackground::_internal_has_subtextargb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_subtextargb() const {
+  return _internal_has_subtextargb();
+}
+inline void PaymentBackground::clear_subtextargb() {
+  _impl_.subtextargb_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint32_t PaymentBackground::_internal_subtextargb() const {
+  return _impl_.subtextargb_;
+}
+inline uint32_t PaymentBackground::subtextargb() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.subtextArgb)
+  return _internal_subtextargb();
+}
+inline void PaymentBackground::_internal_set_subtextargb(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.subtextargb_ = value;
+}
+inline void PaymentBackground::set_subtextargb(uint32_t value) {
+  _internal_set_subtextargb(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.subtextArgb)
+}
+
+// optional .proto.PaymentBackground.MediaData mediaData = 9;
+inline bool PaymentBackground::_internal_has_mediadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr);
+  return value;
+}
+inline bool PaymentBackground::has_mediadata() const {
+  return _internal_has_mediadata();
+}
+inline void PaymentBackground::clear_mediadata() {
+  if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::PaymentBackground_MediaData& PaymentBackground::_internal_mediadata() const {
+  const ::proto::PaymentBackground_MediaData* p = _impl_.mediadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground_MediaData&>(
+      ::proto::_PaymentBackground_MediaData_default_instance_);
+}
+inline const ::proto::PaymentBackground_MediaData& PaymentBackground::mediadata() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.mediaData)
+  return _internal_mediadata();
+}
+inline void PaymentBackground::unsafe_arena_set_allocated_mediadata(
+    ::proto::PaymentBackground_MediaData* mediadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_);
+  }
+  _impl_.mediadata_ = mediadata;
+  if (mediadata) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentBackground.mediaData)
+}
+inline ::proto::PaymentBackground_MediaData* PaymentBackground::release_mediadata() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_;
+  _impl_.mediadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PaymentBackground_MediaData* PaymentBackground::unsafe_arena_release_mediadata() {
+  // @@protoc_insertion_point(field_release:proto.PaymentBackground.mediaData)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_;
+  _impl_.mediadata_ = nullptr;
+  return temp;
+}
+inline ::proto::PaymentBackground_MediaData* PaymentBackground::_internal_mutable_mediadata() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.mediadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PaymentBackground_MediaData>(GetArenaForAllocation());
+    _impl_.mediadata_ = p;
+  }
+  return _impl_.mediadata_;
+}
+inline ::proto::PaymentBackground_MediaData* PaymentBackground::mutable_mediadata() {
+  ::proto::PaymentBackground_MediaData* _msg = _internal_mutable_mediadata();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mediaData)
+  return _msg;
+}
+inline void PaymentBackground::set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.mediadata_;
+  }
+  if (mediadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata);
+    if (message_arena != submessage_arena) {
+      mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, mediadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.mediadata_ = mediadata;
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mediaData)
+}
+
+// optional .proto.PaymentBackground.Type type = 10;
+inline bool PaymentBackground::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PaymentBackground::has_type() const {
+  return _internal_has_type();
+}
+inline void PaymentBackground::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::proto::PaymentBackground_Type PaymentBackground::_internal_type() const {
+  return static_cast< ::proto::PaymentBackground_Type >(_impl_.type_);
+}
+inline ::proto::PaymentBackground_Type PaymentBackground::type() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentBackground.type)
+  return _internal_type();
+}
+inline void PaymentBackground::_internal_set_type(::proto::PaymentBackground_Type value) {
+  assert(::proto::PaymentBackground_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.type_ = value;
+}
+inline void PaymentBackground::set_type(::proto::PaymentBackground_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentBackground.type)
+}
+
+// -------------------------------------------------------------------
+
+// PaymentInfo
+
+// optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
+inline bool PaymentInfo::_internal_has_currencydeprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_currencydeprecated() const {
+  return _internal_has_currencydeprecated();
+}
+inline void PaymentInfo::clear_currencydeprecated() {
+  _impl_.currencydeprecated_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::proto::PaymentInfo_Currency PaymentInfo::_internal_currencydeprecated() const {
+  return static_cast< ::proto::PaymentInfo_Currency >(_impl_.currencydeprecated_);
+}
+inline ::proto::PaymentInfo_Currency PaymentInfo::currencydeprecated() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.currencyDeprecated)
+  return _internal_currencydeprecated();
+}
+inline void PaymentInfo::_internal_set_currencydeprecated(::proto::PaymentInfo_Currency value) {
+  assert(::proto::PaymentInfo_Currency_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.currencydeprecated_ = value;
+}
+inline void PaymentInfo::set_currencydeprecated(::proto::PaymentInfo_Currency value) {
+  _internal_set_currencydeprecated(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.currencyDeprecated)
+}
+
+// optional uint64 amount1000 = 2;
+inline bool PaymentInfo::_internal_has_amount1000() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_amount1000() const {
+  return _internal_has_amount1000();
+}
+inline void PaymentInfo::clear_amount1000() {
+  _impl_.amount1000_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint64_t PaymentInfo::_internal_amount1000() const {
+  return _impl_.amount1000_;
+}
+inline uint64_t PaymentInfo::amount1000() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.amount1000)
+  return _internal_amount1000();
+}
+inline void PaymentInfo::_internal_set_amount1000(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.amount1000_ = value;
+}
+inline void PaymentInfo::set_amount1000(uint64_t value) {
+  _internal_set_amount1000(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.amount1000)
+}
+
+// optional string receiverJid = 3;
+inline bool PaymentInfo::_internal_has_receiverjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_receiverjid() const {
+  return _internal_has_receiverjid();
+}
+inline void PaymentInfo::clear_receiverjid() {
+  _impl_.receiverjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PaymentInfo::receiverjid() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.receiverJid)
+  return _internal_receiverjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentInfo::set_receiverjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.receiverjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.receiverJid)
+}
+inline std::string* PaymentInfo::mutable_receiverjid() {
+  std::string* _s = _internal_mutable_receiverjid();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.receiverJid)
+  return _s;
+}
+inline const std::string& PaymentInfo::_internal_receiverjid() const {
+  return _impl_.receiverjid_.Get();
+}
+inline void PaymentInfo::_internal_set_receiverjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.receiverjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentInfo::_internal_mutable_receiverjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.receiverjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentInfo::release_receiverjid() {
+  // @@protoc_insertion_point(field_release:proto.PaymentInfo.receiverJid)
+  if (!_internal_has_receiverjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.receiverjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.receiverjid_.IsDefault()) {
+    _impl_.receiverjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentInfo::set_allocated_receiverjid(std::string* receiverjid) {
+  if (receiverjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.receiverjid_.SetAllocated(receiverjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.receiverjid_.IsDefault()) {
+    _impl_.receiverjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.receiverJid)
+}
+
+// optional .proto.PaymentInfo.Status status = 4;
+inline bool PaymentInfo::_internal_has_status() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_status() const {
+  return _internal_has_status();
+}
+inline void PaymentInfo::clear_status() {
+  _impl_.status_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline ::proto::PaymentInfo_Status PaymentInfo::_internal_status() const {
+  return static_cast< ::proto::PaymentInfo_Status >(_impl_.status_);
+}
+inline ::proto::PaymentInfo_Status PaymentInfo::status() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.status)
+  return _internal_status();
+}
+inline void PaymentInfo::_internal_set_status(::proto::PaymentInfo_Status value) {
+  assert(::proto::PaymentInfo_Status_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.status_ = value;
+}
+inline void PaymentInfo::set_status(::proto::PaymentInfo_Status value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.status)
+}
+
+// optional uint64 transactionTimestamp = 5;
+inline bool PaymentInfo::_internal_has_transactiontimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_transactiontimestamp() const {
+  return _internal_has_transactiontimestamp();
+}
+inline void PaymentInfo::clear_transactiontimestamp() {
+  _impl_.transactiontimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint64_t PaymentInfo::_internal_transactiontimestamp() const {
+  return _impl_.transactiontimestamp_;
+}
+inline uint64_t PaymentInfo::transactiontimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.transactionTimestamp)
+  return _internal_transactiontimestamp();
+}
+inline void PaymentInfo::_internal_set_transactiontimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.transactiontimestamp_ = value;
+}
+inline void PaymentInfo::set_transactiontimestamp(uint64_t value) {
+  _internal_set_transactiontimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.transactionTimestamp)
+}
+
+// optional .proto.MessageKey requestMessageKey = 6;
+inline bool PaymentInfo::_internal_has_requestmessagekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr);
+  return value;
+}
+inline bool PaymentInfo::has_requestmessagekey() const {
+  return _internal_has_requestmessagekey();
+}
+inline void PaymentInfo::clear_requestmessagekey() {
+  if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::MessageKey& PaymentInfo::_internal_requestmessagekey() const {
+  const ::proto::MessageKey* p = _impl_.requestmessagekey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& PaymentInfo::requestmessagekey() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.requestMessageKey)
+  return _internal_requestmessagekey();
+}
+inline void PaymentInfo::unsafe_arena_set_allocated_requestmessagekey(
+    ::proto::MessageKey* requestmessagekey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_);
+  }
+  _impl_.requestmessagekey_ = requestmessagekey;
+  if (requestmessagekey) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.requestMessageKey)
+}
+inline ::proto::MessageKey* PaymentInfo::release_requestmessagekey() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
+  _impl_.requestmessagekey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* PaymentInfo::unsafe_arena_release_requestmessagekey() {
+  // @@protoc_insertion_point(field_release:proto.PaymentInfo.requestMessageKey)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
+  _impl_.requestmessagekey_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* PaymentInfo::_internal_mutable_requestmessagekey() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.requestmessagekey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.requestmessagekey_ = p;
+  }
+  return _impl_.requestmessagekey_;
+}
+inline ::proto::MessageKey* PaymentInfo::mutable_requestmessagekey() {
+  ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.requestMessageKey)
+  return _msg;
+}
+inline void PaymentInfo::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.requestmessagekey_;
+  }
+  if (requestmessagekey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey);
+    if (message_arena != submessage_arena) {
+      requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requestmessagekey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.requestmessagekey_ = requestmessagekey;
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.requestMessageKey)
+}
+
+// optional uint64 expiryTimestamp = 7;
+inline bool PaymentInfo::_internal_has_expirytimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_expirytimestamp() const {
+  return _internal_has_expirytimestamp();
+}
+inline void PaymentInfo::clear_expirytimestamp() {
+  _impl_.expirytimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint64_t PaymentInfo::_internal_expirytimestamp() const {
+  return _impl_.expirytimestamp_;
+}
+inline uint64_t PaymentInfo::expirytimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.expiryTimestamp)
+  return _internal_expirytimestamp();
+}
+inline void PaymentInfo::_internal_set_expirytimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.expirytimestamp_ = value;
+}
+inline void PaymentInfo::set_expirytimestamp(uint64_t value) {
+  _internal_set_expirytimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.expiryTimestamp)
+}
+
+// optional bool futureproofed = 8;
+inline bool PaymentInfo::_internal_has_futureproofed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_futureproofed() const {
+  return _internal_has_futureproofed();
+}
+inline void PaymentInfo::clear_futureproofed() {
+  _impl_.futureproofed_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool PaymentInfo::_internal_futureproofed() const {
+  return _impl_.futureproofed_;
+}
+inline bool PaymentInfo::futureproofed() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.futureproofed)
+  return _internal_futureproofed();
+}
+inline void PaymentInfo::_internal_set_futureproofed(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.futureproofed_ = value;
+}
+inline void PaymentInfo::set_futureproofed(bool value) {
+  _internal_set_futureproofed(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.futureproofed)
+}
+
+// optional string currency = 9;
+inline bool PaymentInfo::_internal_has_currency() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_currency() const {
+  return _internal_has_currency();
+}
+inline void PaymentInfo::clear_currency() {
+  _impl_.currency_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PaymentInfo::currency() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.currency)
+  return _internal_currency();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PaymentInfo::set_currency(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.currency_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.currency)
+}
+inline std::string* PaymentInfo::mutable_currency() {
+  std::string* _s = _internal_mutable_currency();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.currency)
+  return _s;
+}
+inline const std::string& PaymentInfo::_internal_currency() const {
+  return _impl_.currency_.Get();
+}
+inline void PaymentInfo::_internal_set_currency(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.currency_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PaymentInfo::_internal_mutable_currency() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.currency_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PaymentInfo::release_currency() {
+  // @@protoc_insertion_point(field_release:proto.PaymentInfo.currency)
+  if (!_internal_has_currency()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.currency_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currency_.IsDefault()) {
+    _impl_.currency_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PaymentInfo::set_allocated_currency(std::string* currency) {
+  if (currency != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.currency_.SetAllocated(currency, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.currency_.IsDefault()) {
+    _impl_.currency_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.currency)
+}
+
+// optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
+inline bool PaymentInfo::_internal_has_txnstatus() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_txnstatus() const {
+  return _internal_has_txnstatus();
+}
+inline void PaymentInfo::clear_txnstatus() {
+  _impl_.txnstatus_ = 0;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline ::proto::PaymentInfo_TxnStatus PaymentInfo::_internal_txnstatus() const {
+  return static_cast< ::proto::PaymentInfo_TxnStatus >(_impl_.txnstatus_);
+}
+inline ::proto::PaymentInfo_TxnStatus PaymentInfo::txnstatus() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.txnStatus)
+  return _internal_txnstatus();
+}
+inline void PaymentInfo::_internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value) {
+  assert(::proto::PaymentInfo_TxnStatus_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.txnstatus_ = value;
+}
+inline void PaymentInfo::set_txnstatus(::proto::PaymentInfo_TxnStatus value) {
+  _internal_set_txnstatus(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.txnStatus)
+}
+
+// optional bool useNoviFiatFormat = 11;
+inline bool PaymentInfo::_internal_has_usenovifiatformat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool PaymentInfo::has_usenovifiatformat() const {
+  return _internal_has_usenovifiatformat();
+}
+inline void PaymentInfo::clear_usenovifiatformat() {
+  _impl_.usenovifiatformat_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool PaymentInfo::_internal_usenovifiatformat() const {
+  return _impl_.usenovifiatformat_;
+}
+inline bool PaymentInfo::usenovifiatformat() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.useNoviFiatFormat)
+  return _internal_usenovifiatformat();
+}
+inline void PaymentInfo::_internal_set_usenovifiatformat(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.usenovifiatformat_ = value;
+}
+inline void PaymentInfo::set_usenovifiatformat(bool value) {
+  _internal_set_usenovifiatformat(value);
+  // @@protoc_insertion_point(field_set:proto.PaymentInfo.useNoviFiatFormat)
+}
+
+// optional .proto.Money primaryAmount = 12;
+inline bool PaymentInfo::_internal_has_primaryamount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.primaryamount_ != nullptr);
+  return value;
+}
+inline bool PaymentInfo::has_primaryamount() const {
+  return _internal_has_primaryamount();
+}
+inline void PaymentInfo::clear_primaryamount() {
+  if (_impl_.primaryamount_ != nullptr) _impl_.primaryamount_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::Money& PaymentInfo::_internal_primaryamount() const {
+  const ::proto::Money* p = _impl_.primaryamount_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
+      ::proto::_Money_default_instance_);
+}
+inline const ::proto::Money& PaymentInfo::primaryamount() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.primaryAmount)
+  return _internal_primaryamount();
+}
+inline void PaymentInfo::unsafe_arena_set_allocated_primaryamount(
+    ::proto::Money* primaryamount) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryamount_);
+  }
+  _impl_.primaryamount_ = primaryamount;
+  if (primaryamount) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.primaryAmount)
+}
+inline ::proto::Money* PaymentInfo::release_primaryamount() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Money* temp = _impl_.primaryamount_;
+  _impl_.primaryamount_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Money* PaymentInfo::unsafe_arena_release_primaryamount() {
+  // @@protoc_insertion_point(field_release:proto.PaymentInfo.primaryAmount)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::Money* temp = _impl_.primaryamount_;
+  _impl_.primaryamount_ = nullptr;
+  return temp;
+}
+inline ::proto::Money* PaymentInfo::_internal_mutable_primaryamount() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.primaryamount_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
+    _impl_.primaryamount_ = p;
+  }
+  return _impl_.primaryamount_;
+}
+inline ::proto::Money* PaymentInfo::mutable_primaryamount() {
+  ::proto::Money* _msg = _internal_mutable_primaryamount();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.primaryAmount)
+  return _msg;
+}
+inline void PaymentInfo::set_allocated_primaryamount(::proto::Money* primaryamount) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.primaryamount_;
+  }
+  if (primaryamount) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryamount);
+    if (message_arena != submessage_arena) {
+      primaryamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, primaryamount, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.primaryamount_ = primaryamount;
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.primaryAmount)
+}
+
+// optional .proto.Money exchangeAmount = 13;
+inline bool PaymentInfo::_internal_has_exchangeamount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.exchangeamount_ != nullptr);
+  return value;
+}
+inline bool PaymentInfo::has_exchangeamount() const {
+  return _internal_has_exchangeamount();
+}
+inline void PaymentInfo::clear_exchangeamount() {
+  if (_impl_.exchangeamount_ != nullptr) _impl_.exchangeamount_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Money& PaymentInfo::_internal_exchangeamount() const {
+  const ::proto::Money* p = _impl_.exchangeamount_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
+      ::proto::_Money_default_instance_);
+}
+inline const ::proto::Money& PaymentInfo::exchangeamount() const {
+  // @@protoc_insertion_point(field_get:proto.PaymentInfo.exchangeAmount)
+  return _internal_exchangeamount();
+}
+inline void PaymentInfo::unsafe_arena_set_allocated_exchangeamount(
+    ::proto::Money* exchangeamount) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exchangeamount_);
+  }
+  _impl_.exchangeamount_ = exchangeamount;
+  if (exchangeamount) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.exchangeAmount)
+}
+inline ::proto::Money* PaymentInfo::release_exchangeamount() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Money* temp = _impl_.exchangeamount_;
+  _impl_.exchangeamount_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Money* PaymentInfo::unsafe_arena_release_exchangeamount() {
+  // @@protoc_insertion_point(field_release:proto.PaymentInfo.exchangeAmount)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Money* temp = _impl_.exchangeamount_;
+  _impl_.exchangeamount_ = nullptr;
+  return temp;
+}
+inline ::proto::Money* PaymentInfo::_internal_mutable_exchangeamount() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.exchangeamount_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
+    _impl_.exchangeamount_ = p;
+  }
+  return _impl_.exchangeamount_;
+}
+inline ::proto::Money* PaymentInfo::mutable_exchangeamount() {
+  ::proto::Money* _msg = _internal_mutable_exchangeamount();
+  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.exchangeAmount)
+  return _msg;
+}
+inline void PaymentInfo::set_allocated_exchangeamount(::proto::Money* exchangeamount) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.exchangeamount_;
+  }
+  if (exchangeamount) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exchangeamount);
+    if (message_arena != submessage_arena) {
+      exchangeamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, exchangeamount, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.exchangeamount_ = exchangeamount;
+  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.exchangeAmount)
+}
+
+// -------------------------------------------------------------------
+
+// PendingKeyExchange
+
+// optional uint32 sequence = 1;
+inline bool PendingKeyExchange::_internal_has_sequence() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_sequence() const {
+  return _internal_has_sequence();
+}
+inline void PendingKeyExchange::clear_sequence() {
+  _impl_.sequence_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint32_t PendingKeyExchange::_internal_sequence() const {
+  return _impl_.sequence_;
+}
+inline uint32_t PendingKeyExchange::sequence() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.sequence)
+  return _internal_sequence();
+}
+inline void PendingKeyExchange::_internal_set_sequence(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.sequence_ = value;
+}
+inline void PendingKeyExchange::set_sequence(uint32_t value) {
+  _internal_set_sequence(value);
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.sequence)
+}
+
+// optional bytes localBaseKey = 2;
+inline bool PendingKeyExchange::_internal_has_localbasekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localbasekey() const {
+  return _internal_has_localbasekey();
+}
+inline void PendingKeyExchange::clear_localbasekey() {
+  _impl_.localbasekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PendingKeyExchange::localbasekey() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKey)
+  return _internal_localbasekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localbasekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.localbasekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKey)
+}
+inline std::string* PendingKeyExchange::mutable_localbasekey() {
+  std::string* _s = _internal_mutable_localbasekey();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKey)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localbasekey() const {
+  return _impl_.localbasekey_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localbasekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.localbasekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localbasekey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.localbasekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localbasekey() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKey)
+  if (!_internal_has_localbasekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.localbasekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localbasekey_.IsDefault()) {
+    _impl_.localbasekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localbasekey(std::string* localbasekey) {
+  if (localbasekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.localbasekey_.SetAllocated(localbasekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localbasekey_.IsDefault()) {
+    _impl_.localbasekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKey)
+}
+
+// optional bytes localBaseKeyPrivate = 3;
+inline bool PendingKeyExchange::_internal_has_localbasekeyprivate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localbasekeyprivate() const {
+  return _internal_has_localbasekeyprivate();
+}
+inline void PendingKeyExchange::clear_localbasekeyprivate() {
+  _impl_.localbasekeyprivate_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PendingKeyExchange::localbasekeyprivate() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKeyPrivate)
+  return _internal_localbasekeyprivate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localbasekeyprivate(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.localbasekeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKeyPrivate)
+}
+inline std::string* PendingKeyExchange::mutable_localbasekeyprivate() {
+  std::string* _s = _internal_mutable_localbasekeyprivate();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKeyPrivate)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localbasekeyprivate() const {
+  return _impl_.localbasekeyprivate_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localbasekeyprivate(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.localbasekeyprivate_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localbasekeyprivate() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.localbasekeyprivate_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localbasekeyprivate() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKeyPrivate)
+  if (!_internal_has_localbasekeyprivate()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.localbasekeyprivate_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localbasekeyprivate_.IsDefault()) {
+    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localbasekeyprivate(std::string* localbasekeyprivate) {
+  if (localbasekeyprivate != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.localbasekeyprivate_.SetAllocated(localbasekeyprivate, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localbasekeyprivate_.IsDefault()) {
+    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKeyPrivate)
+}
+
+// optional bytes localRatchetKey = 4;
+inline bool PendingKeyExchange::_internal_has_localratchetkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localratchetkey() const {
+  return _internal_has_localratchetkey();
+}
+inline void PendingKeyExchange::clear_localratchetkey() {
+  _impl_.localratchetkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PendingKeyExchange::localratchetkey() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKey)
+  return _internal_localratchetkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localratchetkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.localratchetkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKey)
+}
+inline std::string* PendingKeyExchange::mutable_localratchetkey() {
+  std::string* _s = _internal_mutable_localratchetkey();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKey)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localratchetkey() const {
+  return _impl_.localratchetkey_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localratchetkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.localratchetkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localratchetkey() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.localratchetkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localratchetkey() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKey)
+  if (!_internal_has_localratchetkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.localratchetkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localratchetkey_.IsDefault()) {
+    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localratchetkey(std::string* localratchetkey) {
+  if (localratchetkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.localratchetkey_.SetAllocated(localratchetkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localratchetkey_.IsDefault()) {
+    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKey)
+}
+
+// optional bytes localRatchetKeyPrivate = 5;
+inline bool PendingKeyExchange::_internal_has_localratchetkeyprivate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localratchetkeyprivate() const {
+  return _internal_has_localratchetkeyprivate();
+}
+inline void PendingKeyExchange::clear_localratchetkeyprivate() {
+  _impl_.localratchetkeyprivate_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PendingKeyExchange::localratchetkeyprivate() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKeyPrivate)
+  return _internal_localratchetkeyprivate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.localratchetkeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKeyPrivate)
+}
+inline std::string* PendingKeyExchange::mutable_localratchetkeyprivate() {
+  std::string* _s = _internal_mutable_localratchetkeyprivate();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKeyPrivate)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localratchetkeyprivate() const {
+  return _impl_.localratchetkeyprivate_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localratchetkeyprivate(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.localratchetkeyprivate_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localratchetkeyprivate() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.localratchetkeyprivate_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localratchetkeyprivate() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKeyPrivate)
+  if (!_internal_has_localratchetkeyprivate()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.localratchetkeyprivate_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localratchetkeyprivate_.IsDefault()) {
+    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate) {
+  if (localratchetkeyprivate != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.localratchetkeyprivate_.SetAllocated(localratchetkeyprivate, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localratchetkeyprivate_.IsDefault()) {
+    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKeyPrivate)
+}
+
+// optional bytes localIdentityKey = 7;
+inline bool PendingKeyExchange::_internal_has_localidentitykey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localidentitykey() const {
+  return _internal_has_localidentitykey();
+}
+inline void PendingKeyExchange::clear_localidentitykey() {
+  _impl_.localidentitykey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PendingKeyExchange::localidentitykey() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKey)
+  return _internal_localidentitykey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localidentitykey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.localidentitykey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKey)
+}
+inline std::string* PendingKeyExchange::mutable_localidentitykey() {
+  std::string* _s = _internal_mutable_localidentitykey();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKey)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localidentitykey() const {
+  return _impl_.localidentitykey_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localidentitykey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.localidentitykey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localidentitykey() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.localidentitykey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localidentitykey() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKey)
+  if (!_internal_has_localidentitykey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.localidentitykey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitykey_.IsDefault()) {
+    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localidentitykey(std::string* localidentitykey) {
+  if (localidentitykey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.localidentitykey_.SetAllocated(localidentitykey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitykey_.IsDefault()) {
+    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKey)
+}
+
+// optional bytes localIdentityKeyPrivate = 8;
+inline bool PendingKeyExchange::_internal_has_localidentitykeyprivate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PendingKeyExchange::has_localidentitykeyprivate() const {
+  return _internal_has_localidentitykeyprivate();
+}
+inline void PendingKeyExchange::clear_localidentitykeyprivate() {
+  _impl_.localidentitykeyprivate_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PendingKeyExchange::localidentitykeyprivate() const {
+  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKeyPrivate)
+  return _internal_localidentitykeyprivate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingKeyExchange::set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.localidentitykeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKeyPrivate)
+}
+inline std::string* PendingKeyExchange::mutable_localidentitykeyprivate() {
+  std::string* _s = _internal_mutable_localidentitykeyprivate();
+  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKeyPrivate)
+  return _s;
+}
+inline const std::string& PendingKeyExchange::_internal_localidentitykeyprivate() const {
+  return _impl_.localidentitykeyprivate_.Get();
+}
+inline void PendingKeyExchange::_internal_set_localidentitykeyprivate(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.localidentitykeyprivate_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::_internal_mutable_localidentitykeyprivate() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.localidentitykeyprivate_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingKeyExchange::release_localidentitykeyprivate() {
+  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKeyPrivate)
+  if (!_internal_has_localidentitykeyprivate()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.localidentitykeyprivate_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitykeyprivate_.IsDefault()) {
+    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingKeyExchange::set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate) {
+  if (localidentitykeyprivate != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.localidentitykeyprivate_.SetAllocated(localidentitykeyprivate, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitykeyprivate_.IsDefault()) {
+    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKeyPrivate)
+}
+
+// -------------------------------------------------------------------
+
+// PendingPreKey
+
+// optional uint32 preKeyId = 1;
+inline bool PendingPreKey::_internal_has_prekeyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PendingPreKey::has_prekeyid() const {
+  return _internal_has_prekeyid();
+}
+inline void PendingPreKey::clear_prekeyid() {
+  _impl_.prekeyid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t PendingPreKey::_internal_prekeyid() const {
+  return _impl_.prekeyid_;
+}
+inline uint32_t PendingPreKey::prekeyid() const {
+  // @@protoc_insertion_point(field_get:proto.PendingPreKey.preKeyId)
+  return _internal_prekeyid();
+}
+inline void PendingPreKey::_internal_set_prekeyid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.prekeyid_ = value;
+}
+inline void PendingPreKey::set_prekeyid(uint32_t value) {
+  _internal_set_prekeyid(value);
+  // @@protoc_insertion_point(field_set:proto.PendingPreKey.preKeyId)
+}
+
+// optional int32 signedPreKeyId = 3;
+inline bool PendingPreKey::_internal_has_signedprekeyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PendingPreKey::has_signedprekeyid() const {
+  return _internal_has_signedprekeyid();
+}
+inline void PendingPreKey::clear_signedprekeyid() {
+  _impl_.signedprekeyid_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t PendingPreKey::_internal_signedprekeyid() const {
+  return _impl_.signedprekeyid_;
+}
+inline int32_t PendingPreKey::signedprekeyid() const {
+  // @@protoc_insertion_point(field_get:proto.PendingPreKey.signedPreKeyId)
+  return _internal_signedprekeyid();
+}
+inline void PendingPreKey::_internal_set_signedprekeyid(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.signedprekeyid_ = value;
+}
+inline void PendingPreKey::set_signedprekeyid(int32_t value) {
+  _internal_set_signedprekeyid(value);
+  // @@protoc_insertion_point(field_set:proto.PendingPreKey.signedPreKeyId)
+}
+
+// optional bytes baseKey = 2;
+inline bool PendingPreKey::_internal_has_basekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PendingPreKey::has_basekey() const {
+  return _internal_has_basekey();
+}
+inline void PendingPreKey::clear_basekey() {
+  _impl_.basekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PendingPreKey::basekey() const {
+  // @@protoc_insertion_point(field_get:proto.PendingPreKey.baseKey)
+  return _internal_basekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PendingPreKey::set_basekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.basekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PendingPreKey.baseKey)
+}
+inline std::string* PendingPreKey::mutable_basekey() {
+  std::string* _s = _internal_mutable_basekey();
+  // @@protoc_insertion_point(field_mutable:proto.PendingPreKey.baseKey)
+  return _s;
+}
+inline const std::string& PendingPreKey::_internal_basekey() const {
+  return _impl_.basekey_.Get();
+}
+inline void PendingPreKey::_internal_set_basekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.basekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PendingPreKey::_internal_mutable_basekey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.basekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PendingPreKey::release_basekey() {
+  // @@protoc_insertion_point(field_release:proto.PendingPreKey.baseKey)
+  if (!_internal_has_basekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.basekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.basekey_.IsDefault()) {
+    _impl_.basekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PendingPreKey::set_allocated_basekey(std::string* basekey) {
+  if (basekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.basekey_.SetAllocated(basekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.basekey_.IsDefault()) {
+    _impl_.basekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PendingPreKey.baseKey)
+}
+
+// -------------------------------------------------------------------
+
+// PhotoChange
+
+// optional bytes oldPhoto = 1;
+inline bool PhotoChange::_internal_has_oldphoto() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PhotoChange::has_oldphoto() const {
+  return _internal_has_oldphoto();
+}
+inline void PhotoChange::clear_oldphoto() {
+  _impl_.oldphoto_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PhotoChange::oldphoto() const {
+  // @@protoc_insertion_point(field_get:proto.PhotoChange.oldPhoto)
+  return _internal_oldphoto();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PhotoChange::set_oldphoto(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.oldphoto_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PhotoChange.oldPhoto)
+}
+inline std::string* PhotoChange::mutable_oldphoto() {
+  std::string* _s = _internal_mutable_oldphoto();
+  // @@protoc_insertion_point(field_mutable:proto.PhotoChange.oldPhoto)
+  return _s;
+}
+inline const std::string& PhotoChange::_internal_oldphoto() const {
+  return _impl_.oldphoto_.Get();
+}
+inline void PhotoChange::_internal_set_oldphoto(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.oldphoto_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PhotoChange::_internal_mutable_oldphoto() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.oldphoto_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PhotoChange::release_oldphoto() {
+  // @@protoc_insertion_point(field_release:proto.PhotoChange.oldPhoto)
+  if (!_internal_has_oldphoto()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.oldphoto_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.oldphoto_.IsDefault()) {
+    _impl_.oldphoto_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PhotoChange::set_allocated_oldphoto(std::string* oldphoto) {
+  if (oldphoto != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.oldphoto_.SetAllocated(oldphoto, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.oldphoto_.IsDefault()) {
+    _impl_.oldphoto_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.oldPhoto)
+}
+
+// optional bytes newPhoto = 2;
+inline bool PhotoChange::_internal_has_newphoto() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PhotoChange::has_newphoto() const {
+  return _internal_has_newphoto();
+}
+inline void PhotoChange::clear_newphoto() {
+  _impl_.newphoto_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PhotoChange::newphoto() const {
+  // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhoto)
+  return _internal_newphoto();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PhotoChange::set_newphoto(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.newphoto_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhoto)
+}
+inline std::string* PhotoChange::mutable_newphoto() {
+  std::string* _s = _internal_mutable_newphoto();
+  // @@protoc_insertion_point(field_mutable:proto.PhotoChange.newPhoto)
+  return _s;
+}
+inline const std::string& PhotoChange::_internal_newphoto() const {
+  return _impl_.newphoto_.Get();
+}
+inline void PhotoChange::_internal_set_newphoto(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.newphoto_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PhotoChange::_internal_mutable_newphoto() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.newphoto_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PhotoChange::release_newphoto() {
+  // @@protoc_insertion_point(field_release:proto.PhotoChange.newPhoto)
+  if (!_internal_has_newphoto()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.newphoto_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.newphoto_.IsDefault()) {
+    _impl_.newphoto_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PhotoChange::set_allocated_newphoto(std::string* newphoto) {
+  if (newphoto != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.newphoto_.SetAllocated(newphoto, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.newphoto_.IsDefault()) {
+    _impl_.newphoto_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.newPhoto)
+}
+
+// optional uint32 newPhotoId = 3;
+inline bool PhotoChange::_internal_has_newphotoid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PhotoChange::has_newphotoid() const {
+  return _internal_has_newphotoid();
+}
+inline void PhotoChange::clear_newphotoid() {
+  _impl_.newphotoid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t PhotoChange::_internal_newphotoid() const {
+  return _impl_.newphotoid_;
+}
+inline uint32_t PhotoChange::newphotoid() const {
+  // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhotoId)
+  return _internal_newphotoid();
+}
+inline void PhotoChange::_internal_set_newphotoid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.newphotoid_ = value;
+}
+inline void PhotoChange::set_newphotoid(uint32_t value) {
+  _internal_set_newphotoid(value);
+  // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhotoId)
+}
+
+// -------------------------------------------------------------------
+
+// Point
+
+// optional int32 xDeprecated = 1;
+inline bool Point::_internal_has_xdeprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Point::has_xdeprecated() const {
+  return _internal_has_xdeprecated();
+}
+inline void Point::clear_xdeprecated() {
+  _impl_.xdeprecated_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t Point::_internal_xdeprecated() const {
+  return _impl_.xdeprecated_;
+}
+inline int32_t Point::xdeprecated() const {
+  // @@protoc_insertion_point(field_get:proto.Point.xDeprecated)
+  return _internal_xdeprecated();
+}
+inline void Point::_internal_set_xdeprecated(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.xdeprecated_ = value;
+}
+inline void Point::set_xdeprecated(int32_t value) {
+  _internal_set_xdeprecated(value);
+  // @@protoc_insertion_point(field_set:proto.Point.xDeprecated)
+}
+
+// optional int32 yDeprecated = 2;
+inline bool Point::_internal_has_ydeprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Point::has_ydeprecated() const {
+  return _internal_has_ydeprecated();
+}
+inline void Point::clear_ydeprecated() {
+  _impl_.ydeprecated_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t Point::_internal_ydeprecated() const {
+  return _impl_.ydeprecated_;
+}
+inline int32_t Point::ydeprecated() const {
+  // @@protoc_insertion_point(field_get:proto.Point.yDeprecated)
+  return _internal_ydeprecated();
+}
+inline void Point::_internal_set_ydeprecated(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.ydeprecated_ = value;
+}
+inline void Point::set_ydeprecated(int32_t value) {
+  _internal_set_ydeprecated(value);
+  // @@protoc_insertion_point(field_set:proto.Point.yDeprecated)
+}
+
+// optional double x = 3;
+inline bool Point::_internal_has_x() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Point::has_x() const {
+  return _internal_has_x();
+}
+inline void Point::clear_x() {
+  _impl_.x_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline double Point::_internal_x() const {
+  return _impl_.x_;
+}
+inline double Point::x() const {
+  // @@protoc_insertion_point(field_get:proto.Point.x)
+  return _internal_x();
+}
+inline void Point::_internal_set_x(double value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.x_ = value;
+}
+inline void Point::set_x(double value) {
+  _internal_set_x(value);
+  // @@protoc_insertion_point(field_set:proto.Point.x)
+}
+
+// optional double y = 4;
+inline bool Point::_internal_has_y() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Point::has_y() const {
+  return _internal_has_y();
+}
+inline void Point::clear_y() {
+  _impl_.y_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline double Point::_internal_y() const {
+  return _impl_.y_;
+}
+inline double Point::y() const {
+  // @@protoc_insertion_point(field_get:proto.Point.y)
+  return _internal_y();
+}
+inline void Point::_internal_set_y(double value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.y_ = value;
+}
+inline void Point::set_y(double value) {
+  _internal_set_y(value);
+  // @@protoc_insertion_point(field_set:proto.Point.y)
+}
+
+// -------------------------------------------------------------------
+
+// PollAdditionalMetadata
+
+// optional bool pollInvalidated = 1;
+inline bool PollAdditionalMetadata::_internal_has_pollinvalidated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PollAdditionalMetadata::has_pollinvalidated() const {
+  return _internal_has_pollinvalidated();
+}
+inline void PollAdditionalMetadata::clear_pollinvalidated() {
+  _impl_.pollinvalidated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool PollAdditionalMetadata::_internal_pollinvalidated() const {
+  return _impl_.pollinvalidated_;
+}
+inline bool PollAdditionalMetadata::pollinvalidated() const {
+  // @@protoc_insertion_point(field_get:proto.PollAdditionalMetadata.pollInvalidated)
+  return _internal_pollinvalidated();
+}
+inline void PollAdditionalMetadata::_internal_set_pollinvalidated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.pollinvalidated_ = value;
+}
+inline void PollAdditionalMetadata::set_pollinvalidated(bool value) {
+  _internal_set_pollinvalidated(value);
+  // @@protoc_insertion_point(field_set:proto.PollAdditionalMetadata.pollInvalidated)
+}
+
+// -------------------------------------------------------------------
+
+// PollEncValue
+
+// optional bytes encPayload = 1;
+inline bool PollEncValue::_internal_has_encpayload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PollEncValue::has_encpayload() const {
+  return _internal_has_encpayload();
+}
+inline void PollEncValue::clear_encpayload() {
+  _impl_.encpayload_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PollEncValue::encpayload() const {
+  // @@protoc_insertion_point(field_get:proto.PollEncValue.encPayload)
+  return _internal_encpayload();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.encpayload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PollEncValue.encPayload)
+}
+inline std::string* PollEncValue::mutable_encpayload() {
+  std::string* _s = _internal_mutable_encpayload();
+  // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encPayload)
+  return _s;
+}
+inline const std::string& PollEncValue::_internal_encpayload() const {
+  return _impl_.encpayload_.Get();
+}
+inline void PollEncValue::_internal_set_encpayload(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.encpayload_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PollEncValue::_internal_mutable_encpayload() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.encpayload_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PollEncValue::release_encpayload() {
+  // @@protoc_insertion_point(field_release:proto.PollEncValue.encPayload)
+  if (!_internal_has_encpayload()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.encpayload_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encpayload_.IsDefault()) {
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PollEncValue::set_allocated_encpayload(std::string* encpayload) {
+  if (encpayload != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encpayload_.IsDefault()) {
+    _impl_.encpayload_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encPayload)
+}
+
+// optional bytes encIv = 2;
+inline bool PollEncValue::_internal_has_enciv() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PollEncValue::has_enciv() const {
+  return _internal_has_enciv();
+}
+inline void PollEncValue::clear_enciv() {
+  _impl_.enciv_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PollEncValue::enciv() const {
+  // @@protoc_insertion_point(field_get:proto.PollEncValue.encIv)
+  return _internal_enciv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.enciv_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PollEncValue.encIv)
+}
+inline std::string* PollEncValue::mutable_enciv() {
+  std::string* _s = _internal_mutable_enciv();
+  // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encIv)
+  return _s;
+}
+inline const std::string& PollEncValue::_internal_enciv() const {
+  return _impl_.enciv_.Get();
+}
+inline void PollEncValue::_internal_set_enciv(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.enciv_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PollEncValue::_internal_mutable_enciv() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.enciv_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PollEncValue::release_enciv() {
+  // @@protoc_insertion_point(field_release:proto.PollEncValue.encIv)
+  if (!_internal_has_enciv()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.enciv_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enciv_.IsDefault()) {
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PollEncValue::set_allocated_enciv(std::string* enciv) {
+  if (enciv != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.enciv_.IsDefault()) {
+    _impl_.enciv_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encIv)
+}
+
+// -------------------------------------------------------------------
+
+// PollUpdate
+
+// optional .proto.MessageKey pollUpdateMessageKey = 1;
+inline bool PollUpdate::_internal_has_pollupdatemessagekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pollupdatemessagekey_ != nullptr);
+  return value;
+}
+inline bool PollUpdate::has_pollupdatemessagekey() const {
+  return _internal_has_pollupdatemessagekey();
+}
+inline void PollUpdate::clear_pollupdatemessagekey() {
+  if (_impl_.pollupdatemessagekey_ != nullptr) _impl_.pollupdatemessagekey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& PollUpdate::_internal_pollupdatemessagekey() const {
+  const ::proto::MessageKey* p = _impl_.pollupdatemessagekey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& PollUpdate::pollupdatemessagekey() const {
+  // @@protoc_insertion_point(field_get:proto.PollUpdate.pollUpdateMessageKey)
+  return _internal_pollupdatemessagekey();
+}
+inline void PollUpdate::unsafe_arena_set_allocated_pollupdatemessagekey(
+    ::proto::MessageKey* pollupdatemessagekey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessagekey_);
+  }
+  _impl_.pollupdatemessagekey_ = pollupdatemessagekey;
+  if (pollupdatemessagekey) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.pollUpdateMessageKey)
+}
+inline ::proto::MessageKey* PollUpdate::release_pollupdatemessagekey() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_;
+  _impl_.pollupdatemessagekey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* PollUpdate::unsafe_arena_release_pollupdatemessagekey() {
+  // @@protoc_insertion_point(field_release:proto.PollUpdate.pollUpdateMessageKey)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_;
+  _impl_.pollupdatemessagekey_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* PollUpdate::_internal_mutable_pollupdatemessagekey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.pollupdatemessagekey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.pollupdatemessagekey_ = p;
+  }
+  return _impl_.pollupdatemessagekey_;
+}
+inline ::proto::MessageKey* PollUpdate::mutable_pollupdatemessagekey() {
+  ::proto::MessageKey* _msg = _internal_mutable_pollupdatemessagekey();
+  // @@protoc_insertion_point(field_mutable:proto.PollUpdate.pollUpdateMessageKey)
+  return _msg;
+}
+inline void PollUpdate::set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pollupdatemessagekey_;
+  }
+  if (pollupdatemessagekey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessagekey);
+    if (message_arena != submessage_arena) {
+      pollupdatemessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pollupdatemessagekey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.pollupdatemessagekey_ = pollupdatemessagekey;
+  // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.pollUpdateMessageKey)
+}
+
+// optional .proto.Message.PollVoteMessage vote = 2;
+inline bool PollUpdate::_internal_has_vote() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr);
+  return value;
+}
+inline bool PollUpdate::has_vote() const {
+  return _internal_has_vote();
+}
+inline void PollUpdate::clear_vote() {
+  if (_impl_.vote_ != nullptr) _impl_.vote_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_PollVoteMessage& PollUpdate::_internal_vote() const {
+  const ::proto::Message_PollVoteMessage* p = _impl_.vote_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollVoteMessage&>(
+      ::proto::_Message_PollVoteMessage_default_instance_);
+}
+inline const ::proto::Message_PollVoteMessage& PollUpdate::vote() const {
+  // @@protoc_insertion_point(field_get:proto.PollUpdate.vote)
+  return _internal_vote();
+}
+inline void PollUpdate::unsafe_arena_set_allocated_vote(
+    ::proto::Message_PollVoteMessage* vote) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_);
+  }
+  _impl_.vote_ = vote;
+  if (vote) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.vote)
+}
+inline ::proto::Message_PollVoteMessage* PollUpdate::release_vote() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_PollVoteMessage* temp = _impl_.vote_;
+  _impl_.vote_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_PollVoteMessage* PollUpdate::unsafe_arena_release_vote() {
+  // @@protoc_insertion_point(field_release:proto.PollUpdate.vote)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_PollVoteMessage* temp = _impl_.vote_;
+  _impl_.vote_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_PollVoteMessage* PollUpdate::_internal_mutable_vote() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.vote_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_PollVoteMessage>(GetArenaForAllocation());
+    _impl_.vote_ = p;
+  }
+  return _impl_.vote_;
+}
+inline ::proto::Message_PollVoteMessage* PollUpdate::mutable_vote() {
+  ::proto::Message_PollVoteMessage* _msg = _internal_mutable_vote();
+  // @@protoc_insertion_point(field_mutable:proto.PollUpdate.vote)
+  return _msg;
+}
+inline void PollUpdate::set_allocated_vote(::proto::Message_PollVoteMessage* vote) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.vote_;
+  }
+  if (vote) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote);
+    if (message_arena != submessage_arena) {
+      vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, vote, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.vote_ = vote;
+  // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.vote)
+}
+
+// optional int64 senderTimestampMs = 3;
+inline bool PollUpdate::_internal_has_sendertimestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PollUpdate::has_sendertimestampms() const {
+  return _internal_has_sendertimestampms();
+}
+inline void PollUpdate::clear_sendertimestampms() {
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t PollUpdate::_internal_sendertimestampms() const {
+  return _impl_.sendertimestampms_;
+}
+inline int64_t PollUpdate::sendertimestampms() const {
+  // @@protoc_insertion_point(field_get:proto.PollUpdate.senderTimestampMs)
+  return _internal_sendertimestampms();
+}
+inline void PollUpdate::_internal_set_sendertimestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.sendertimestampms_ = value;
+}
+inline void PollUpdate::set_sendertimestampms(int64_t value) {
+  _internal_set_sendertimestampms(value);
+  // @@protoc_insertion_point(field_set:proto.PollUpdate.senderTimestampMs)
+}
+
+// -------------------------------------------------------------------
+
+// PreKeyRecordStructure
+
+// optional uint32 id = 1;
+inline bool PreKeyRecordStructure::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PreKeyRecordStructure::has_id() const {
+  return _internal_has_id();
+}
+inline void PreKeyRecordStructure::clear_id() {
+  _impl_.id_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t PreKeyRecordStructure::_internal_id() const {
+  return _impl_.id_;
+}
+inline uint32_t PreKeyRecordStructure::id() const {
+  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.id)
+  return _internal_id();
+}
+inline void PreKeyRecordStructure::_internal_set_id(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.id_ = value;
+}
+inline void PreKeyRecordStructure::set_id(uint32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.id)
+}
+
+// optional bytes publicKey = 2;
+inline bool PreKeyRecordStructure::_internal_has_publickey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PreKeyRecordStructure::has_publickey() const {
+  return _internal_has_publickey();
+}
+inline void PreKeyRecordStructure::clear_publickey() {
+  _impl_.publickey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PreKeyRecordStructure::publickey() const {
+  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.publicKey)
+  return _internal_publickey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.publickey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.publicKey)
+}
+inline std::string* PreKeyRecordStructure::mutable_publickey() {
+  std::string* _s = _internal_mutable_publickey();
+  // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.publicKey)
+  return _s;
+}
+inline const std::string& PreKeyRecordStructure::_internal_publickey() const {
+  return _impl_.publickey_.Get();
+}
+inline void PreKeyRecordStructure::_internal_set_publickey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.publickey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PreKeyRecordStructure::_internal_mutable_publickey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.publickey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PreKeyRecordStructure::release_publickey() {
+  // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.publicKey)
+  if (!_internal_has_publickey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.publickey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PreKeyRecordStructure::set_allocated_publickey(std::string* publickey) {
+  if (publickey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.publicKey)
+}
+
+// optional bytes privateKey = 3;
+inline bool PreKeyRecordStructure::_internal_has_privatekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PreKeyRecordStructure::has_privatekey() const {
+  return _internal_has_privatekey();
+}
+inline void PreKeyRecordStructure::clear_privatekey() {
+  _impl_.privatekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PreKeyRecordStructure::privatekey() const {
+  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.privateKey)
+  return _internal_privatekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.privatekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.privateKey)
+}
+inline std::string* PreKeyRecordStructure::mutable_privatekey() {
+  std::string* _s = _internal_mutable_privatekey();
+  // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.privateKey)
+  return _s;
+}
+inline const std::string& PreKeyRecordStructure::_internal_privatekey() const {
+  return _impl_.privatekey_.Get();
+}
+inline void PreKeyRecordStructure::_internal_set_privatekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.privatekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PreKeyRecordStructure::_internal_mutable_privatekey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PreKeyRecordStructure::release_privatekey() {
+  // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.privateKey)
+  if (!_internal_has_privatekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.privatekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void PreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) {
+  if (privatekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.privateKey)
+}
+
+// -------------------------------------------------------------------
+
+// Pushname
+
+// optional string id = 1;
+inline bool Pushname::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Pushname::has_id() const {
+  return _internal_has_id();
+}
+inline void Pushname::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Pushname::id() const {
+  // @@protoc_insertion_point(field_get:proto.Pushname.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Pushname::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Pushname.id)
+}
+inline std::string* Pushname::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.Pushname.id)
+  return _s;
+}
+inline const std::string& Pushname::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void Pushname::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Pushname::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Pushname::release_id() {
+  // @@protoc_insertion_point(field_release:proto.Pushname.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Pushname::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Pushname.id)
+}
+
+// optional string pushname = 2;
+inline bool Pushname::_internal_has_pushname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Pushname::has_pushname() const {
+  return _internal_has_pushname();
+}
+inline void Pushname::clear_pushname() {
+  _impl_.pushname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Pushname::pushname() const {
+  // @@protoc_insertion_point(field_get:proto.Pushname.pushname)
+  return _internal_pushname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Pushname::set_pushname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Pushname.pushname)
+}
+inline std::string* Pushname::mutable_pushname() {
+  std::string* _s = _internal_mutable_pushname();
+  // @@protoc_insertion_point(field_mutable:proto.Pushname.pushname)
+  return _s;
+}
+inline const std::string& Pushname::_internal_pushname() const {
+  return _impl_.pushname_.Get();
+}
+inline void Pushname::_internal_set_pushname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.pushname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Pushname::_internal_mutable_pushname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.pushname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Pushname::release_pushname() {
+  // @@protoc_insertion_point(field_release:proto.Pushname.pushname)
+  if (!_internal_has_pushname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.pushname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Pushname::set_allocated_pushname(std::string* pushname) {
+  if (pushname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Pushname.pushname)
+}
+
+// -------------------------------------------------------------------
+
+// Reaction
+
+// optional .proto.MessageKey key = 1;
+inline bool Reaction::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool Reaction::has_key() const {
+  return _internal_has_key();
+}
+inline void Reaction::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::MessageKey& Reaction::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& Reaction::key() const {
+  // @@protoc_insertion_point(field_get:proto.Reaction.key)
+  return _internal_key();
+}
+inline void Reaction::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Reaction.key)
+}
+inline ::proto::MessageKey* Reaction::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* Reaction::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.Reaction.key)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* Reaction::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* Reaction::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.Reaction.key)
+  return _msg;
+}
+inline void Reaction::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.Reaction.key)
+}
+
+// optional string text = 2;
+inline bool Reaction::_internal_has_text() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Reaction::has_text() const {
+  return _internal_has_text();
+}
+inline void Reaction::clear_text() {
+  _impl_.text_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Reaction::text() const {
+  // @@protoc_insertion_point(field_get:proto.Reaction.text)
+  return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Reaction::set_text(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Reaction.text)
+}
+inline std::string* Reaction::mutable_text() {
+  std::string* _s = _internal_mutable_text();
+  // @@protoc_insertion_point(field_mutable:proto.Reaction.text)
+  return _s;
+}
+inline const std::string& Reaction::_internal_text() const {
+  return _impl_.text_.Get();
+}
+inline void Reaction::_internal_set_text(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Reaction::_internal_mutable_text() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Reaction::release_text() {
+  // @@protoc_insertion_point(field_release:proto.Reaction.text)
+  if (!_internal_has_text()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.text_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Reaction::set_allocated_text(std::string* text) {
+  if (text != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.text_.IsDefault()) {
+    _impl_.text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Reaction.text)
+}
+
+// optional string groupingKey = 3;
+inline bool Reaction::_internal_has_groupingkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Reaction::has_groupingkey() const {
+  return _internal_has_groupingkey();
+}
+inline void Reaction::clear_groupingkey() {
+  _impl_.groupingkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& Reaction::groupingkey() const {
+  // @@protoc_insertion_point(field_get:proto.Reaction.groupingKey)
+  return _internal_groupingkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Reaction::set_groupingkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.groupingkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.Reaction.groupingKey)
+}
+inline std::string* Reaction::mutable_groupingkey() {
+  std::string* _s = _internal_mutable_groupingkey();
+  // @@protoc_insertion_point(field_mutable:proto.Reaction.groupingKey)
+  return _s;
+}
+inline const std::string& Reaction::_internal_groupingkey() const {
+  return _impl_.groupingkey_.Get();
+}
+inline void Reaction::_internal_set_groupingkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.groupingkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Reaction::_internal_mutable_groupingkey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.groupingkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Reaction::release_groupingkey() {
+  // @@protoc_insertion_point(field_release:proto.Reaction.groupingKey)
+  if (!_internal_has_groupingkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.groupingkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupingkey_.IsDefault()) {
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Reaction::set_allocated_groupingkey(std::string* groupingkey) {
+  if (groupingkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.groupingkey_.IsDefault()) {
+    _impl_.groupingkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.Reaction.groupingKey)
+}
+
+// optional int64 senderTimestampMs = 4;
+inline bool Reaction::_internal_has_sendertimestampms() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Reaction::has_sendertimestampms() const {
+  return _internal_has_sendertimestampms();
+}
+inline void Reaction::clear_sendertimestampms() {
+  _impl_.sendertimestampms_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t Reaction::_internal_sendertimestampms() const {
+  return _impl_.sendertimestampms_;
+}
+inline int64_t Reaction::sendertimestampms() const {
+  // @@protoc_insertion_point(field_get:proto.Reaction.senderTimestampMs)
+  return _internal_sendertimestampms();
+}
+inline void Reaction::_internal_set_sendertimestampms(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.sendertimestampms_ = value;
+}
+inline void Reaction::set_sendertimestampms(int64_t value) {
+  _internal_set_sendertimestampms(value);
+  // @@protoc_insertion_point(field_set:proto.Reaction.senderTimestampMs)
+}
+
+// optional bool unread = 5;
+inline bool Reaction::_internal_has_unread() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool Reaction::has_unread() const {
+  return _internal_has_unread();
+}
+inline void Reaction::clear_unread() {
+  _impl_.unread_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool Reaction::_internal_unread() const {
+  return _impl_.unread_;
+}
+inline bool Reaction::unread() const {
+  // @@protoc_insertion_point(field_get:proto.Reaction.unread)
+  return _internal_unread();
+}
+inline void Reaction::_internal_set_unread(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.unread_ = value;
+}
+inline void Reaction::set_unread(bool value) {
+  _internal_set_unread(value);
+  // @@protoc_insertion_point(field_set:proto.Reaction.unread)
+}
+
+// -------------------------------------------------------------------
+
+// RecentEmojiWeight
+
+// optional string emoji = 1;
+inline bool RecentEmojiWeight::_internal_has_emoji() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RecentEmojiWeight::has_emoji() const {
+  return _internal_has_emoji();
+}
+inline void RecentEmojiWeight::clear_emoji() {
+  _impl_.emoji_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RecentEmojiWeight::emoji() const {
+  // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.emoji)
+  return _internal_emoji();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RecentEmojiWeight::set_emoji(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.emoji_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.emoji)
+}
+inline std::string* RecentEmojiWeight::mutable_emoji() {
+  std::string* _s = _internal_mutable_emoji();
+  // @@protoc_insertion_point(field_mutable:proto.RecentEmojiWeight.emoji)
+  return _s;
+}
+inline const std::string& RecentEmojiWeight::_internal_emoji() const {
+  return _impl_.emoji_.Get();
+}
+inline void RecentEmojiWeight::_internal_set_emoji(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.emoji_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RecentEmojiWeight::_internal_mutable_emoji() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.emoji_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RecentEmojiWeight::release_emoji() {
+  // @@protoc_insertion_point(field_release:proto.RecentEmojiWeight.emoji)
+  if (!_internal_has_emoji()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.emoji_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.emoji_.IsDefault()) {
+    _impl_.emoji_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void RecentEmojiWeight::set_allocated_emoji(std::string* emoji) {
+  if (emoji != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.emoji_.SetAllocated(emoji, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.emoji_.IsDefault()) {
+    _impl_.emoji_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.RecentEmojiWeight.emoji)
+}
+
+// optional float weight = 2;
+inline bool RecentEmojiWeight::_internal_has_weight() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RecentEmojiWeight::has_weight() const {
+  return _internal_has_weight();
+}
+inline void RecentEmojiWeight::clear_weight() {
+  _impl_.weight_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline float RecentEmojiWeight::_internal_weight() const {
+  return _impl_.weight_;
+}
+inline float RecentEmojiWeight::weight() const {
+  // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.weight)
+  return _internal_weight();
+}
+inline void RecentEmojiWeight::_internal_set_weight(float value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.weight_ = value;
+}
+inline void RecentEmojiWeight::set_weight(float value) {
+  _internal_set_weight(value);
+  // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.weight)
+}
+
+// -------------------------------------------------------------------
+
+// RecordStructure
+
+// optional .proto.SessionStructure currentSession = 1;
+inline bool RecordStructure::_internal_has_currentsession() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.currentsession_ != nullptr);
+  return value;
+}
+inline bool RecordStructure::has_currentsession() const {
+  return _internal_has_currentsession();
+}
+inline void RecordStructure::clear_currentsession() {
+  if (_impl_.currentsession_ != nullptr) _impl_.currentsession_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SessionStructure& RecordStructure::_internal_currentsession() const {
+  const ::proto::SessionStructure* p = _impl_.currentsession_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SessionStructure&>(
+      ::proto::_SessionStructure_default_instance_);
+}
+inline const ::proto::SessionStructure& RecordStructure::currentsession() const {
+  // @@protoc_insertion_point(field_get:proto.RecordStructure.currentSession)
+  return _internal_currentsession();
+}
+inline void RecordStructure::unsafe_arena_set_allocated_currentsession(
+    ::proto::SessionStructure* currentsession) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentsession_);
+  }
+  _impl_.currentsession_ = currentsession;
+  if (currentsession) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.RecordStructure.currentSession)
+}
+inline ::proto::SessionStructure* RecordStructure::release_currentsession() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SessionStructure* temp = _impl_.currentsession_;
+  _impl_.currentsession_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SessionStructure* RecordStructure::unsafe_arena_release_currentsession() {
+  // @@protoc_insertion_point(field_release:proto.RecordStructure.currentSession)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SessionStructure* temp = _impl_.currentsession_;
+  _impl_.currentsession_ = nullptr;
+  return temp;
+}
+inline ::proto::SessionStructure* RecordStructure::_internal_mutable_currentsession() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.currentsession_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SessionStructure>(GetArenaForAllocation());
+    _impl_.currentsession_ = p;
+  }
+  return _impl_.currentsession_;
+}
+inline ::proto::SessionStructure* RecordStructure::mutable_currentsession() {
+  ::proto::SessionStructure* _msg = _internal_mutable_currentsession();
+  // @@protoc_insertion_point(field_mutable:proto.RecordStructure.currentSession)
+  return _msg;
+}
+inline void RecordStructure::set_allocated_currentsession(::proto::SessionStructure* currentsession) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.currentsession_;
+  }
+  if (currentsession) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentsession);
+    if (message_arena != submessage_arena) {
+      currentsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, currentsession, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.currentsession_ = currentsession;
+  // @@protoc_insertion_point(field_set_allocated:proto.RecordStructure.currentSession)
+}
+
+// repeated .proto.SessionStructure previousSessions = 2;
+inline int RecordStructure::_internal_previoussessions_size() const {
+  return _impl_.previoussessions_.size();
+}
+inline int RecordStructure::previoussessions_size() const {
+  return _internal_previoussessions_size();
+}
+inline void RecordStructure::clear_previoussessions() {
+  _impl_.previoussessions_.Clear();
+}
+inline ::proto::SessionStructure* RecordStructure::mutable_previoussessions(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.RecordStructure.previousSessions)
+  return _impl_.previoussessions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >*
+RecordStructure::mutable_previoussessions() {
+  // @@protoc_insertion_point(field_mutable_list:proto.RecordStructure.previousSessions)
+  return &_impl_.previoussessions_;
+}
+inline const ::proto::SessionStructure& RecordStructure::_internal_previoussessions(int index) const {
+  return _impl_.previoussessions_.Get(index);
+}
+inline const ::proto::SessionStructure& RecordStructure::previoussessions(int index) const {
+  // @@protoc_insertion_point(field_get:proto.RecordStructure.previousSessions)
+  return _internal_previoussessions(index);
+}
+inline ::proto::SessionStructure* RecordStructure::_internal_add_previoussessions() {
+  return _impl_.previoussessions_.Add();
+}
+inline ::proto::SessionStructure* RecordStructure::add_previoussessions() {
+  ::proto::SessionStructure* _add = _internal_add_previoussessions();
+  // @@protoc_insertion_point(field_add:proto.RecordStructure.previousSessions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >&
+RecordStructure::previoussessions() const {
+  // @@protoc_insertion_point(field_list:proto.RecordStructure.previousSessions)
+  return _impl_.previoussessions_;
+}
+
+// -------------------------------------------------------------------
+
+// SenderChainKey
+
+// optional uint32 iteration = 1;
+inline bool SenderChainKey::_internal_has_iteration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SenderChainKey::has_iteration() const {
+  return _internal_has_iteration();
+}
+inline void SenderChainKey::clear_iteration() {
+  _impl_.iteration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t SenderChainKey::_internal_iteration() const {
+  return _impl_.iteration_;
+}
+inline uint32_t SenderChainKey::iteration() const {
+  // @@protoc_insertion_point(field_get:proto.SenderChainKey.iteration)
+  return _internal_iteration();
+}
+inline void SenderChainKey::_internal_set_iteration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.iteration_ = value;
+}
+inline void SenderChainKey::set_iteration(uint32_t value) {
+  _internal_set_iteration(value);
+  // @@protoc_insertion_point(field_set:proto.SenderChainKey.iteration)
+}
+
+// optional bytes seed = 2;
+inline bool SenderChainKey::_internal_has_seed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SenderChainKey::has_seed() const {
+  return _internal_has_seed();
+}
+inline void SenderChainKey::clear_seed() {
+  _impl_.seed_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SenderChainKey::seed() const {
+  // @@protoc_insertion_point(field_get:proto.SenderChainKey.seed)
+  return _internal_seed();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SenderChainKey::set_seed(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.seed_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SenderChainKey.seed)
+}
+inline std::string* SenderChainKey::mutable_seed() {
+  std::string* _s = _internal_mutable_seed();
+  // @@protoc_insertion_point(field_mutable:proto.SenderChainKey.seed)
+  return _s;
+}
+inline const std::string& SenderChainKey::_internal_seed() const {
+  return _impl_.seed_.Get();
+}
+inline void SenderChainKey::_internal_set_seed(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.seed_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SenderChainKey::_internal_mutable_seed() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.seed_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SenderChainKey::release_seed() {
+  // @@protoc_insertion_point(field_release:proto.SenderChainKey.seed)
+  if (!_internal_has_seed()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.seed_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.seed_.IsDefault()) {
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SenderChainKey::set_allocated_seed(std::string* seed) {
+  if (seed != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.seed_.SetAllocated(seed, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.seed_.IsDefault()) {
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderChainKey.seed)
+}
+
+// -------------------------------------------------------------------
+
+// SenderKeyRecordStructure
+
+// repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
+inline int SenderKeyRecordStructure::_internal_senderkeystates_size() const {
+  return _impl_.senderkeystates_.size();
+}
+inline int SenderKeyRecordStructure::senderkeystates_size() const {
+  return _internal_senderkeystates_size();
+}
+inline void SenderKeyRecordStructure::clear_senderkeystates() {
+  _impl_.senderkeystates_.Clear();
+}
+inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::mutable_senderkeystates(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SenderKeyRecordStructure.senderKeyStates)
+  return _impl_.senderkeystates_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >*
+SenderKeyRecordStructure::mutable_senderkeystates() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyRecordStructure.senderKeyStates)
+  return &_impl_.senderkeystates_;
+}
+inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::_internal_senderkeystates(int index) const {
+  return _impl_.senderkeystates_.Get(index);
+}
+inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::senderkeystates(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SenderKeyRecordStructure.senderKeyStates)
+  return _internal_senderkeystates(index);
+}
+inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::_internal_add_senderkeystates() {
+  return _impl_.senderkeystates_.Add();
+}
+inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::add_senderkeystates() {
+  ::proto::SenderKeyStateStructure* _add = _internal_add_senderkeystates();
+  // @@protoc_insertion_point(field_add:proto.SenderKeyRecordStructure.senderKeyStates)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >&
+SenderKeyRecordStructure::senderkeystates() const {
+  // @@protoc_insertion_point(field_list:proto.SenderKeyRecordStructure.senderKeyStates)
+  return _impl_.senderkeystates_;
+}
+
+// -------------------------------------------------------------------
+
+// SenderKeyStateStructure
+
+// optional uint32 senderKeyId = 1;
+inline bool SenderKeyStateStructure::_internal_has_senderkeyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SenderKeyStateStructure::has_senderkeyid() const {
+  return _internal_has_senderkeyid();
+}
+inline void SenderKeyStateStructure::clear_senderkeyid() {
+  _impl_.senderkeyid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t SenderKeyStateStructure::_internal_senderkeyid() const {
+  return _impl_.senderkeyid_;
+}
+inline uint32_t SenderKeyStateStructure::senderkeyid() const {
+  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderKeyId)
+  return _internal_senderkeyid();
+}
+inline void SenderKeyStateStructure::_internal_set_senderkeyid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.senderkeyid_ = value;
+}
+inline void SenderKeyStateStructure::set_senderkeyid(uint32_t value) {
+  _internal_set_senderkeyid(value);
+  // @@protoc_insertion_point(field_set:proto.SenderKeyStateStructure.senderKeyId)
+}
+
+// optional .proto.SenderChainKey senderChainKey = 2;
+inline bool SenderKeyStateStructure::_internal_has_senderchainkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.senderchainkey_ != nullptr);
+  return value;
+}
+inline bool SenderKeyStateStructure::has_senderchainkey() const {
+  return _internal_has_senderchainkey();
+}
+inline void SenderKeyStateStructure::clear_senderchainkey() {
+  if (_impl_.senderchainkey_ != nullptr) _impl_.senderchainkey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SenderChainKey& SenderKeyStateStructure::_internal_senderchainkey() const {
+  const ::proto::SenderChainKey* p = _impl_.senderchainkey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SenderChainKey&>(
+      ::proto::_SenderChainKey_default_instance_);
+}
+inline const ::proto::SenderChainKey& SenderKeyStateStructure::senderchainkey() const {
+  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderChainKey)
+  return _internal_senderchainkey();
+}
+inline void SenderKeyStateStructure::unsafe_arena_set_allocated_senderchainkey(
+    ::proto::SenderChainKey* senderchainkey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchainkey_);
+  }
+  _impl_.senderchainkey_ = senderchainkey;
+  if (senderchainkey) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderChainKey)
+}
+inline ::proto::SenderChainKey* SenderKeyStateStructure::release_senderchainkey() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SenderChainKey* temp = _impl_.senderchainkey_;
+  _impl_.senderchainkey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SenderChainKey* SenderKeyStateStructure::unsafe_arena_release_senderchainkey() {
+  // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderChainKey)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SenderChainKey* temp = _impl_.senderchainkey_;
+  _impl_.senderchainkey_ = nullptr;
+  return temp;
+}
+inline ::proto::SenderChainKey* SenderKeyStateStructure::_internal_mutable_senderchainkey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.senderchainkey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SenderChainKey>(GetArenaForAllocation());
+    _impl_.senderchainkey_ = p;
+  }
+  return _impl_.senderchainkey_;
+}
+inline ::proto::SenderChainKey* SenderKeyStateStructure::mutable_senderchainkey() {
+  ::proto::SenderChainKey* _msg = _internal_mutable_senderchainkey();
+  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderChainKey)
+  return _msg;
+}
+inline void SenderKeyStateStructure::set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.senderchainkey_;
+  }
+  if (senderchainkey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchainkey);
+    if (message_arena != submessage_arena) {
+      senderchainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, senderchainkey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.senderchainkey_ = senderchainkey;
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderChainKey)
+}
+
+// optional .proto.SenderSigningKey senderSigningKey = 3;
+inline bool SenderKeyStateStructure::_internal_has_sendersigningkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.sendersigningkey_ != nullptr);
+  return value;
+}
+inline bool SenderKeyStateStructure::has_sendersigningkey() const {
+  return _internal_has_sendersigningkey();
+}
+inline void SenderKeyStateStructure::clear_sendersigningkey() {
+  if (_impl_.sendersigningkey_ != nullptr) _impl_.sendersigningkey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::SenderSigningKey& SenderKeyStateStructure::_internal_sendersigningkey() const {
+  const ::proto::SenderSigningKey* p = _impl_.sendersigningkey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SenderSigningKey&>(
+      ::proto::_SenderSigningKey_default_instance_);
+}
+inline const ::proto::SenderSigningKey& SenderKeyStateStructure::sendersigningkey() const {
+  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderSigningKey)
+  return _internal_sendersigningkey();
+}
+inline void SenderKeyStateStructure::unsafe_arena_set_allocated_sendersigningkey(
+    ::proto::SenderSigningKey* sendersigningkey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendersigningkey_);
+  }
+  _impl_.sendersigningkey_ = sendersigningkey;
+  if (sendersigningkey) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderSigningKey)
+}
+inline ::proto::SenderSigningKey* SenderKeyStateStructure::release_sendersigningkey() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_;
+  _impl_.sendersigningkey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SenderSigningKey* SenderKeyStateStructure::unsafe_arena_release_sendersigningkey() {
+  // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderSigningKey)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_;
+  _impl_.sendersigningkey_ = nullptr;
+  return temp;
+}
+inline ::proto::SenderSigningKey* SenderKeyStateStructure::_internal_mutable_sendersigningkey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.sendersigningkey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SenderSigningKey>(GetArenaForAllocation());
+    _impl_.sendersigningkey_ = p;
+  }
+  return _impl_.sendersigningkey_;
+}
+inline ::proto::SenderSigningKey* SenderKeyStateStructure::mutable_sendersigningkey() {
+  ::proto::SenderSigningKey* _msg = _internal_mutable_sendersigningkey();
+  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderSigningKey)
+  return _msg;
+}
+inline void SenderKeyStateStructure::set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.sendersigningkey_;
+  }
+  if (sendersigningkey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendersigningkey);
+    if (message_arena != submessage_arena) {
+      sendersigningkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, sendersigningkey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.sendersigningkey_ = sendersigningkey;
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderSigningKey)
+}
+
+// repeated .proto.SenderMessageKey senderMessageKeys = 4;
+inline int SenderKeyStateStructure::_internal_sendermessagekeys_size() const {
+  return _impl_.sendermessagekeys_.size();
+}
+inline int SenderKeyStateStructure::sendermessagekeys_size() const {
+  return _internal_sendermessagekeys_size();
+}
+inline void SenderKeyStateStructure::clear_sendermessagekeys() {
+  _impl_.sendermessagekeys_.Clear();
+}
+inline ::proto::SenderMessageKey* SenderKeyStateStructure::mutable_sendermessagekeys(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderMessageKeys)
+  return _impl_.sendermessagekeys_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >*
+SenderKeyStateStructure::mutable_sendermessagekeys() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyStateStructure.senderMessageKeys)
+  return &_impl_.sendermessagekeys_;
+}
+inline const ::proto::SenderMessageKey& SenderKeyStateStructure::_internal_sendermessagekeys(int index) const {
+  return _impl_.sendermessagekeys_.Get(index);
+}
+inline const ::proto::SenderMessageKey& SenderKeyStateStructure::sendermessagekeys(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderMessageKeys)
+  return _internal_sendermessagekeys(index);
+}
+inline ::proto::SenderMessageKey* SenderKeyStateStructure::_internal_add_sendermessagekeys() {
+  return _impl_.sendermessagekeys_.Add();
+}
+inline ::proto::SenderMessageKey* SenderKeyStateStructure::add_sendermessagekeys() {
+  ::proto::SenderMessageKey* _add = _internal_add_sendermessagekeys();
+  // @@protoc_insertion_point(field_add:proto.SenderKeyStateStructure.senderMessageKeys)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >&
+SenderKeyStateStructure::sendermessagekeys() const {
+  // @@protoc_insertion_point(field_list:proto.SenderKeyStateStructure.senderMessageKeys)
+  return _impl_.sendermessagekeys_;
+}
+
+// -------------------------------------------------------------------
+
+// SenderMessageKey
+
+// optional uint32 iteration = 1;
+inline bool SenderMessageKey::_internal_has_iteration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SenderMessageKey::has_iteration() const {
+  return _internal_has_iteration();
+}
+inline void SenderMessageKey::clear_iteration() {
+  _impl_.iteration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t SenderMessageKey::_internal_iteration() const {
+  return _impl_.iteration_;
+}
+inline uint32_t SenderMessageKey::iteration() const {
+  // @@protoc_insertion_point(field_get:proto.SenderMessageKey.iteration)
+  return _internal_iteration();
+}
+inline void SenderMessageKey::_internal_set_iteration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.iteration_ = value;
+}
+inline void SenderMessageKey::set_iteration(uint32_t value) {
+  _internal_set_iteration(value);
+  // @@protoc_insertion_point(field_set:proto.SenderMessageKey.iteration)
+}
+
+// optional bytes seed = 2;
+inline bool SenderMessageKey::_internal_has_seed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SenderMessageKey::has_seed() const {
+  return _internal_has_seed();
+}
+inline void SenderMessageKey::clear_seed() {
+  _impl_.seed_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SenderMessageKey::seed() const {
+  // @@protoc_insertion_point(field_get:proto.SenderMessageKey.seed)
+  return _internal_seed();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SenderMessageKey::set_seed(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.seed_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SenderMessageKey.seed)
+}
+inline std::string* SenderMessageKey::mutable_seed() {
+  std::string* _s = _internal_mutable_seed();
+  // @@protoc_insertion_point(field_mutable:proto.SenderMessageKey.seed)
+  return _s;
+}
+inline const std::string& SenderMessageKey::_internal_seed() const {
+  return _impl_.seed_.Get();
+}
+inline void SenderMessageKey::_internal_set_seed(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.seed_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SenderMessageKey::_internal_mutable_seed() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.seed_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SenderMessageKey::release_seed() {
+  // @@protoc_insertion_point(field_release:proto.SenderMessageKey.seed)
+  if (!_internal_has_seed()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.seed_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.seed_.IsDefault()) {
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SenderMessageKey::set_allocated_seed(std::string* seed) {
+  if (seed != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.seed_.SetAllocated(seed, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.seed_.IsDefault()) {
+    _impl_.seed_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderMessageKey.seed)
+}
+
+// -------------------------------------------------------------------
+
+// SenderSigningKey
+
+// optional bytes public = 1;
+inline bool SenderSigningKey::_internal_has_public_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SenderSigningKey::has_public_() const {
+  return _internal_has_public_();
+}
+inline void SenderSigningKey::clear_public_() {
+  _impl_.public__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SenderSigningKey::public_() const {
+  // @@protoc_insertion_point(field_get:proto.SenderSigningKey.public)
+  return _internal_public_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SenderSigningKey::set_public_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.public__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SenderSigningKey.public)
+}
+inline std::string* SenderSigningKey::mutable_public_() {
+  std::string* _s = _internal_mutable_public_();
+  // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.public)
+  return _s;
+}
+inline const std::string& SenderSigningKey::_internal_public_() const {
+  return _impl_.public__.Get();
+}
+inline void SenderSigningKey::_internal_set_public_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.public__.Set(value, GetArenaForAllocation());
+}
+inline std::string* SenderSigningKey::_internal_mutable_public_() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.public__.Mutable(GetArenaForAllocation());
+}
+inline std::string* SenderSigningKey::release_public_() {
+  // @@protoc_insertion_point(field_release:proto.SenderSigningKey.public)
+  if (!_internal_has_public_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.public__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.public__.IsDefault()) {
+    _impl_.public__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SenderSigningKey::set_allocated_public_(std::string* public_) {
+  if (public_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.public__.SetAllocated(public_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.public__.IsDefault()) {
+    _impl_.public__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.public)
+}
+
+// optional bytes private = 2;
+inline bool SenderSigningKey::_internal_has_private_() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SenderSigningKey::has_private_() const {
+  return _internal_has_private_();
+}
+inline void SenderSigningKey::clear_private_() {
+  _impl_.private__.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SenderSigningKey::private_() const {
+  // @@protoc_insertion_point(field_get:proto.SenderSigningKey.private)
+  return _internal_private_();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SenderSigningKey::set_private_(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.private__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SenderSigningKey.private)
+}
+inline std::string* SenderSigningKey::mutable_private_() {
+  std::string* _s = _internal_mutable_private_();
+  // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.private)
+  return _s;
+}
+inline const std::string& SenderSigningKey::_internal_private_() const {
+  return _impl_.private__.Get();
+}
+inline void SenderSigningKey::_internal_set_private_(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.private__.Set(value, GetArenaForAllocation());
+}
+inline std::string* SenderSigningKey::_internal_mutable_private_() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.private__.Mutable(GetArenaForAllocation());
+}
+inline std::string* SenderSigningKey::release_private_() {
+  // @@protoc_insertion_point(field_release:proto.SenderSigningKey.private)
+  if (!_internal_has_private_()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.private__.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.private__.IsDefault()) {
+    _impl_.private__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SenderSigningKey::set_allocated_private_(std::string* private_) {
+  if (private_ != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.private__.SetAllocated(private_, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.private__.IsDefault()) {
+    _impl_.private__.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.private)
+}
+
+// -------------------------------------------------------------------
+
+// ServerErrorReceipt
+
+// optional string stanzaId = 1;
+inline bool ServerErrorReceipt::_internal_has_stanzaid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ServerErrorReceipt::has_stanzaid() const {
+  return _internal_has_stanzaid();
+}
+inline void ServerErrorReceipt::clear_stanzaid() {
+  _impl_.stanzaid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ServerErrorReceipt::stanzaid() const {
+  // @@protoc_insertion_point(field_get:proto.ServerErrorReceipt.stanzaId)
+  return _internal_stanzaid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ServerErrorReceipt::set_stanzaid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.ServerErrorReceipt.stanzaId)
+}
+inline std::string* ServerErrorReceipt::mutable_stanzaid() {
+  std::string* _s = _internal_mutable_stanzaid();
+  // @@protoc_insertion_point(field_mutable:proto.ServerErrorReceipt.stanzaId)
+  return _s;
+}
+inline const std::string& ServerErrorReceipt::_internal_stanzaid() const {
+  return _impl_.stanzaid_.Get();
+}
+inline void ServerErrorReceipt::_internal_set_stanzaid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ServerErrorReceipt::_internal_mutable_stanzaid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ServerErrorReceipt::release_stanzaid() {
+  // @@protoc_insertion_point(field_release:proto.ServerErrorReceipt.stanzaId)
+  if (!_internal_has_stanzaid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.stanzaid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ServerErrorReceipt::set_allocated_stanzaid(std::string* stanzaid) {
+  if (stanzaid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.stanzaid_.IsDefault()) {
+    _impl_.stanzaid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.ServerErrorReceipt.stanzaId)
+}
+
+// -------------------------------------------------------------------
+
+// SessionStructure
+
+// optional uint32 sessionVersion = 1;
+inline bool SessionStructure::_internal_has_sessionversion() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_sessionversion() const {
+  return _internal_has_sessionversion();
+}
+inline void SessionStructure::clear_sessionversion() {
+  _impl_.sessionversion_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint32_t SessionStructure::_internal_sessionversion() const {
+  return _impl_.sessionversion_;
+}
+inline uint32_t SessionStructure::sessionversion() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.sessionVersion)
+  return _internal_sessionversion();
+}
+inline void SessionStructure::_internal_set_sessionversion(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.sessionversion_ = value;
+}
+inline void SessionStructure::set_sessionversion(uint32_t value) {
+  _internal_set_sessionversion(value);
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.sessionVersion)
+}
+
+// optional bytes localIdentityPublic = 2;
+inline bool SessionStructure::_internal_has_localidentitypublic() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_localidentitypublic() const {
+  return _internal_has_localidentitypublic();
+}
+inline void SessionStructure::clear_localidentitypublic() {
+  _impl_.localidentitypublic_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionStructure::localidentitypublic() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.localIdentityPublic)
+  return _internal_localidentitypublic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionStructure::set_localidentitypublic(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.localidentitypublic_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.localIdentityPublic)
+}
+inline std::string* SessionStructure::mutable_localidentitypublic() {
+  std::string* _s = _internal_mutable_localidentitypublic();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.localIdentityPublic)
+  return _s;
+}
+inline const std::string& SessionStructure::_internal_localidentitypublic() const {
+  return _impl_.localidentitypublic_.Get();
+}
+inline void SessionStructure::_internal_set_localidentitypublic(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.localidentitypublic_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SessionStructure::_internal_mutable_localidentitypublic() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.localidentitypublic_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SessionStructure::release_localidentitypublic() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.localIdentityPublic)
+  if (!_internal_has_localidentitypublic()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.localidentitypublic_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitypublic_.IsDefault()) {
+    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SessionStructure::set_allocated_localidentitypublic(std::string* localidentitypublic) {
+  if (localidentitypublic != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.localidentitypublic_.SetAllocated(localidentitypublic, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.localidentitypublic_.IsDefault()) {
+    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.localIdentityPublic)
+}
+
+// optional bytes remoteIdentityPublic = 3;
+inline bool SessionStructure::_internal_has_remoteidentitypublic() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_remoteidentitypublic() const {
+  return _internal_has_remoteidentitypublic();
+}
+inline void SessionStructure::clear_remoteidentitypublic() {
+  _impl_.remoteidentitypublic_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SessionStructure::remoteidentitypublic() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteIdentityPublic)
+  return _internal_remoteidentitypublic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionStructure::set_remoteidentitypublic(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.remoteidentitypublic_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteIdentityPublic)
+}
+inline std::string* SessionStructure::mutable_remoteidentitypublic() {
+  std::string* _s = _internal_mutable_remoteidentitypublic();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.remoteIdentityPublic)
+  return _s;
+}
+inline const std::string& SessionStructure::_internal_remoteidentitypublic() const {
+  return _impl_.remoteidentitypublic_.Get();
+}
+inline void SessionStructure::_internal_set_remoteidentitypublic(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.remoteidentitypublic_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SessionStructure::_internal_mutable_remoteidentitypublic() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.remoteidentitypublic_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SessionStructure::release_remoteidentitypublic() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.remoteIdentityPublic)
+  if (!_internal_has_remoteidentitypublic()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.remoteidentitypublic_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remoteidentitypublic_.IsDefault()) {
+    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SessionStructure::set_allocated_remoteidentitypublic(std::string* remoteidentitypublic) {
+  if (remoteidentitypublic != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.remoteidentitypublic_.SetAllocated(remoteidentitypublic, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remoteidentitypublic_.IsDefault()) {
+    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.remoteIdentityPublic)
+}
+
+// optional bytes rootKey = 4;
+inline bool SessionStructure::_internal_has_rootkey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_rootkey() const {
+  return _internal_has_rootkey();
+}
+inline void SessionStructure::clear_rootkey() {
+  _impl_.rootkey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SessionStructure::rootkey() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.rootKey)
+  return _internal_rootkey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionStructure::set_rootkey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.rootkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.rootKey)
+}
+inline std::string* SessionStructure::mutable_rootkey() {
+  std::string* _s = _internal_mutable_rootkey();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.rootKey)
+  return _s;
+}
+inline const std::string& SessionStructure::_internal_rootkey() const {
+  return _impl_.rootkey_.Get();
+}
+inline void SessionStructure::_internal_set_rootkey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.rootkey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SessionStructure::_internal_mutable_rootkey() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.rootkey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SessionStructure::release_rootkey() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.rootKey)
+  if (!_internal_has_rootkey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.rootkey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rootkey_.IsDefault()) {
+    _impl_.rootkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SessionStructure::set_allocated_rootkey(std::string* rootkey) {
+  if (rootkey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.rootkey_.SetAllocated(rootkey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rootkey_.IsDefault()) {
+    _impl_.rootkey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.rootKey)
+}
+
+// optional uint32 previousCounter = 5;
+inline bool SessionStructure::_internal_has_previouscounter() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_previouscounter() const {
+  return _internal_has_previouscounter();
+}
+inline void SessionStructure::clear_previouscounter() {
+  _impl_.previouscounter_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint32_t SessionStructure::_internal_previouscounter() const {
+  return _impl_.previouscounter_;
+}
+inline uint32_t SessionStructure::previouscounter() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.previousCounter)
+  return _internal_previouscounter();
+}
+inline void SessionStructure::_internal_set_previouscounter(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.previouscounter_ = value;
+}
+inline void SessionStructure::set_previouscounter(uint32_t value) {
+  _internal_set_previouscounter(value);
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.previousCounter)
+}
+
+// optional .proto.Chain senderChain = 6;
+inline bool SessionStructure::_internal_has_senderchain() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.senderchain_ != nullptr);
+  return value;
+}
+inline bool SessionStructure::has_senderchain() const {
+  return _internal_has_senderchain();
+}
+inline void SessionStructure::clear_senderchain() {
+  if (_impl_.senderchain_ != nullptr) _impl_.senderchain_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::Chain& SessionStructure::_internal_senderchain() const {
+  const ::proto::Chain* p = _impl_.senderchain_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Chain&>(
+      ::proto::_Chain_default_instance_);
+}
+inline const ::proto::Chain& SessionStructure::senderchain() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.senderChain)
+  return _internal_senderchain();
+}
+inline void SessionStructure::unsafe_arena_set_allocated_senderchain(
+    ::proto::Chain* senderchain) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchain_);
+  }
+  _impl_.senderchain_ = senderchain;
+  if (senderchain) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.senderChain)
+}
+inline ::proto::Chain* SessionStructure::release_senderchain() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Chain* temp = _impl_.senderchain_;
+  _impl_.senderchain_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Chain* SessionStructure::unsafe_arena_release_senderchain() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.senderChain)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::Chain* temp = _impl_.senderchain_;
+  _impl_.senderchain_ = nullptr;
+  return temp;
+}
+inline ::proto::Chain* SessionStructure::_internal_mutable_senderchain() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.senderchain_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Chain>(GetArenaForAllocation());
+    _impl_.senderchain_ = p;
+  }
+  return _impl_.senderchain_;
+}
+inline ::proto::Chain* SessionStructure::mutable_senderchain() {
+  ::proto::Chain* _msg = _internal_mutable_senderchain();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.senderChain)
+  return _msg;
+}
+inline void SessionStructure::set_allocated_senderchain(::proto::Chain* senderchain) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.senderchain_;
+  }
+  if (senderchain) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchain);
+    if (message_arena != submessage_arena) {
+      senderchain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, senderchain, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.senderchain_ = senderchain;
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.senderChain)
+}
+
+// repeated .proto.Chain receiverChains = 7;
+inline int SessionStructure::_internal_receiverchains_size() const {
+  return _impl_.receiverchains_.size();
+}
+inline int SessionStructure::receiverchains_size() const {
+  return _internal_receiverchains_size();
+}
+inline void SessionStructure::clear_receiverchains() {
+  _impl_.receiverchains_.Clear();
+}
+inline ::proto::Chain* SessionStructure::mutable_receiverchains(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.receiverChains)
+  return _impl_.receiverchains_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >*
+SessionStructure::mutable_receiverchains() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SessionStructure.receiverChains)
+  return &_impl_.receiverchains_;
+}
+inline const ::proto::Chain& SessionStructure::_internal_receiverchains(int index) const {
+  return _impl_.receiverchains_.Get(index);
+}
+inline const ::proto::Chain& SessionStructure::receiverchains(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.receiverChains)
+  return _internal_receiverchains(index);
+}
+inline ::proto::Chain* SessionStructure::_internal_add_receiverchains() {
+  return _impl_.receiverchains_.Add();
+}
+inline ::proto::Chain* SessionStructure::add_receiverchains() {
+  ::proto::Chain* _add = _internal_add_receiverchains();
+  // @@protoc_insertion_point(field_add:proto.SessionStructure.receiverChains)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >&
+SessionStructure::receiverchains() const {
+  // @@protoc_insertion_point(field_list:proto.SessionStructure.receiverChains)
+  return _impl_.receiverchains_;
+}
+
+// optional .proto.PendingKeyExchange pendingKeyExchange = 8;
+inline bool SessionStructure::_internal_has_pendingkeyexchange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pendingkeyexchange_ != nullptr);
+  return value;
+}
+inline bool SessionStructure::has_pendingkeyexchange() const {
+  return _internal_has_pendingkeyexchange();
+}
+inline void SessionStructure::clear_pendingkeyexchange() {
+  if (_impl_.pendingkeyexchange_ != nullptr) _impl_.pendingkeyexchange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::PendingKeyExchange& SessionStructure::_internal_pendingkeyexchange() const {
+  const ::proto::PendingKeyExchange* p = _impl_.pendingkeyexchange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PendingKeyExchange&>(
+      ::proto::_PendingKeyExchange_default_instance_);
+}
+inline const ::proto::PendingKeyExchange& SessionStructure::pendingkeyexchange() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingKeyExchange)
+  return _internal_pendingkeyexchange();
+}
+inline void SessionStructure::unsafe_arena_set_allocated_pendingkeyexchange(
+    ::proto::PendingKeyExchange* pendingkeyexchange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingkeyexchange_);
+  }
+  _impl_.pendingkeyexchange_ = pendingkeyexchange;
+  if (pendingkeyexchange) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingKeyExchange)
+}
+inline ::proto::PendingKeyExchange* SessionStructure::release_pendingkeyexchange() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_;
+  _impl_.pendingkeyexchange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PendingKeyExchange* SessionStructure::unsafe_arena_release_pendingkeyexchange() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingKeyExchange)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_;
+  _impl_.pendingkeyexchange_ = nullptr;
+  return temp;
+}
+inline ::proto::PendingKeyExchange* SessionStructure::_internal_mutable_pendingkeyexchange() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.pendingkeyexchange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PendingKeyExchange>(GetArenaForAllocation());
+    _impl_.pendingkeyexchange_ = p;
+  }
+  return _impl_.pendingkeyexchange_;
+}
+inline ::proto::PendingKeyExchange* SessionStructure::mutable_pendingkeyexchange() {
+  ::proto::PendingKeyExchange* _msg = _internal_mutable_pendingkeyexchange();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingKeyExchange)
+  return _msg;
+}
+inline void SessionStructure::set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pendingkeyexchange_;
+  }
+  if (pendingkeyexchange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingkeyexchange);
+    if (message_arena != submessage_arena) {
+      pendingkeyexchange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pendingkeyexchange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.pendingkeyexchange_ = pendingkeyexchange;
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingKeyExchange)
+}
+
+// optional .proto.PendingPreKey pendingPreKey = 9;
+inline bool SessionStructure::_internal_has_pendingprekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pendingprekey_ != nullptr);
+  return value;
+}
+inline bool SessionStructure::has_pendingprekey() const {
+  return _internal_has_pendingprekey();
+}
+inline void SessionStructure::clear_pendingprekey() {
+  if (_impl_.pendingprekey_ != nullptr) _impl_.pendingprekey_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::PendingPreKey& SessionStructure::_internal_pendingprekey() const {
+  const ::proto::PendingPreKey* p = _impl_.pendingprekey_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PendingPreKey&>(
+      ::proto::_PendingPreKey_default_instance_);
+}
+inline const ::proto::PendingPreKey& SessionStructure::pendingprekey() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingPreKey)
+  return _internal_pendingprekey();
+}
+inline void SessionStructure::unsafe_arena_set_allocated_pendingprekey(
+    ::proto::PendingPreKey* pendingprekey) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingprekey_);
+  }
+  _impl_.pendingprekey_ = pendingprekey;
+  if (pendingprekey) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingPreKey)
+}
+inline ::proto::PendingPreKey* SessionStructure::release_pendingprekey() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::PendingPreKey* temp = _impl_.pendingprekey_;
+  _impl_.pendingprekey_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PendingPreKey* SessionStructure::unsafe_arena_release_pendingprekey() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingPreKey)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::PendingPreKey* temp = _impl_.pendingprekey_;
+  _impl_.pendingprekey_ = nullptr;
+  return temp;
+}
+inline ::proto::PendingPreKey* SessionStructure::_internal_mutable_pendingprekey() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.pendingprekey_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PendingPreKey>(GetArenaForAllocation());
+    _impl_.pendingprekey_ = p;
+  }
+  return _impl_.pendingprekey_;
+}
+inline ::proto::PendingPreKey* SessionStructure::mutable_pendingprekey() {
+  ::proto::PendingPreKey* _msg = _internal_mutable_pendingprekey();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingPreKey)
+  return _msg;
+}
+inline void SessionStructure::set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pendingprekey_;
+  }
+  if (pendingprekey) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingprekey);
+    if (message_arena != submessage_arena) {
+      pendingprekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pendingprekey, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.pendingprekey_ = pendingprekey;
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingPreKey)
+}
+
+// optional uint32 remoteRegistrationId = 10;
+inline bool SessionStructure::_internal_has_remoteregistrationid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_remoteregistrationid() const {
+  return _internal_has_remoteregistrationid();
+}
+inline void SessionStructure::clear_remoteregistrationid() {
+  _impl_.remoteregistrationid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint32_t SessionStructure::_internal_remoteregistrationid() const {
+  return _impl_.remoteregistrationid_;
+}
+inline uint32_t SessionStructure::remoteregistrationid() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteRegistrationId)
+  return _internal_remoteregistrationid();
+}
+inline void SessionStructure::_internal_set_remoteregistrationid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.remoteregistrationid_ = value;
+}
+inline void SessionStructure::set_remoteregistrationid(uint32_t value) {
+  _internal_set_remoteregistrationid(value);
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteRegistrationId)
+}
+
+// optional uint32 localRegistrationId = 11;
+inline bool SessionStructure::_internal_has_localregistrationid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_localregistrationid() const {
+  return _internal_has_localregistrationid();
+}
+inline void SessionStructure::clear_localregistrationid() {
+  _impl_.localregistrationid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline uint32_t SessionStructure::_internal_localregistrationid() const {
+  return _impl_.localregistrationid_;
+}
+inline uint32_t SessionStructure::localregistrationid() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.localRegistrationId)
+  return _internal_localregistrationid();
+}
+inline void SessionStructure::_internal_set_localregistrationid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.localregistrationid_ = value;
+}
+inline void SessionStructure::set_localregistrationid(uint32_t value) {
+  _internal_set_localregistrationid(value);
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.localRegistrationId)
+}
+
+// optional bool needsRefresh = 12;
+inline bool SessionStructure::_internal_has_needsrefresh() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_needsrefresh() const {
+  return _internal_has_needsrefresh();
+}
+inline void SessionStructure::clear_needsrefresh() {
+  _impl_.needsrefresh_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool SessionStructure::_internal_needsrefresh() const {
+  return _impl_.needsrefresh_;
+}
+inline bool SessionStructure::needsrefresh() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.needsRefresh)
+  return _internal_needsrefresh();
+}
+inline void SessionStructure::_internal_set_needsrefresh(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.needsrefresh_ = value;
+}
+inline void SessionStructure::set_needsrefresh(bool value) {
+  _internal_set_needsrefresh(value);
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.needsRefresh)
+}
+
+// optional bytes aliceBaseKey = 13;
+inline bool SessionStructure::_internal_has_alicebasekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionStructure::has_alicebasekey() const {
+  return _internal_has_alicebasekey();
+}
+inline void SessionStructure::clear_alicebasekey() {
+  _impl_.alicebasekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SessionStructure::alicebasekey() const {
+  // @@protoc_insertion_point(field_get:proto.SessionStructure.aliceBaseKey)
+  return _internal_alicebasekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionStructure::set_alicebasekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.alicebasekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SessionStructure.aliceBaseKey)
+}
+inline std::string* SessionStructure::mutable_alicebasekey() {
+  std::string* _s = _internal_mutable_alicebasekey();
+  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.aliceBaseKey)
+  return _s;
+}
+inline const std::string& SessionStructure::_internal_alicebasekey() const {
+  return _impl_.alicebasekey_.Get();
+}
+inline void SessionStructure::_internal_set_alicebasekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.alicebasekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SessionStructure::_internal_mutable_alicebasekey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.alicebasekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SessionStructure::release_alicebasekey() {
+  // @@protoc_insertion_point(field_release:proto.SessionStructure.aliceBaseKey)
+  if (!_internal_has_alicebasekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.alicebasekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.alicebasekey_.IsDefault()) {
+    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SessionStructure::set_allocated_alicebasekey(std::string* alicebasekey) {
+  if (alicebasekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.alicebasekey_.SetAllocated(alicebasekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.alicebasekey_.IsDefault()) {
+    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.aliceBaseKey)
+}
+
+// -------------------------------------------------------------------
+
+// SignedPreKeyRecordStructure
+
+// optional uint32 id = 1;
+inline bool SignedPreKeyRecordStructure::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SignedPreKeyRecordStructure::has_id() const {
+  return _internal_has_id();
+}
+inline void SignedPreKeyRecordStructure::clear_id() {
+  _impl_.id_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline uint32_t SignedPreKeyRecordStructure::_internal_id() const {
+  return _impl_.id_;
+}
+inline uint32_t SignedPreKeyRecordStructure::id() const {
+  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.id)
+  return _internal_id();
+}
+inline void SignedPreKeyRecordStructure::_internal_set_id(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.id_ = value;
+}
+inline void SignedPreKeyRecordStructure::set_id(uint32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.id)
+}
+
+// optional bytes publicKey = 2;
+inline bool SignedPreKeyRecordStructure::_internal_has_publickey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedPreKeyRecordStructure::has_publickey() const {
+  return _internal_has_publickey();
+}
+inline void SignedPreKeyRecordStructure::clear_publickey() {
+  _impl_.publickey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedPreKeyRecordStructure::publickey() const {
+  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.publicKey)
+  return _internal_publickey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedPreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.publickey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.publicKey)
+}
+inline std::string* SignedPreKeyRecordStructure::mutable_publickey() {
+  std::string* _s = _internal_mutable_publickey();
+  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.publicKey)
+  return _s;
+}
+inline const std::string& SignedPreKeyRecordStructure::_internal_publickey() const {
+  return _impl_.publickey_.Get();
+}
+inline void SignedPreKeyRecordStructure::_internal_set_publickey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.publickey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::_internal_mutable_publickey() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.publickey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::release_publickey() {
+  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.publicKey)
+  if (!_internal_has_publickey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.publickey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SignedPreKeyRecordStructure::set_allocated_publickey(std::string* publickey) {
+  if (publickey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.publickey_.IsDefault()) {
+    _impl_.publickey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.publicKey)
+}
+
+// optional bytes privateKey = 3;
+inline bool SignedPreKeyRecordStructure::_internal_has_privatekey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedPreKeyRecordStructure::has_privatekey() const {
+  return _internal_has_privatekey();
+}
+inline void SignedPreKeyRecordStructure::clear_privatekey() {
+  _impl_.privatekey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedPreKeyRecordStructure::privatekey() const {
+  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.privateKey)
+  return _internal_privatekey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedPreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.privatekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.privateKey)
+}
+inline std::string* SignedPreKeyRecordStructure::mutable_privatekey() {
+  std::string* _s = _internal_mutable_privatekey();
+  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.privateKey)
+  return _s;
+}
+inline const std::string& SignedPreKeyRecordStructure::_internal_privatekey() const {
+  return _impl_.privatekey_.Get();
+}
+inline void SignedPreKeyRecordStructure::_internal_set_privatekey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.privatekey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::_internal_mutable_privatekey() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::release_privatekey() {
+  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.privateKey)
+  if (!_internal_has_privatekey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.privatekey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SignedPreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) {
+  if (privatekey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.privatekey_.IsDefault()) {
+    _impl_.privatekey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.privateKey)
+}
+
+// optional bytes signature = 4;
+inline bool SignedPreKeyRecordStructure::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedPreKeyRecordStructure::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedPreKeyRecordStructure::clear_signature() {
+  _impl_.signature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SignedPreKeyRecordStructure::signature() const {
+  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedPreKeyRecordStructure::set_signature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.signature)
+}
+inline std::string* SignedPreKeyRecordStructure::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.signature)
+  return _s;
+}
+inline const std::string& SignedPreKeyRecordStructure::_internal_signature() const {
+  return _impl_.signature_.Get();
+}
+inline void SignedPreKeyRecordStructure::_internal_set_signature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.signature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.signature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SignedPreKeyRecordStructure::release_signature() {
+  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.signature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SignedPreKeyRecordStructure::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.signature)
+}
+
+// optional fixed64 timestamp = 5;
+inline bool SignedPreKeyRecordStructure::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SignedPreKeyRecordStructure::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void SignedPreKeyRecordStructure::clear_timestamp() {
+  _impl_.timestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t SignedPreKeyRecordStructure::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline uint64_t SignedPreKeyRecordStructure::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.timestamp)
+  return _internal_timestamp();
+}
+inline void SignedPreKeyRecordStructure::_internal_set_timestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.timestamp_ = value;
+}
+inline void SignedPreKeyRecordStructure::set_timestamp(uint64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// StatusPSA
+
+// required uint64 campaignId = 44;
+inline bool StatusPSA::_internal_has_campaignid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool StatusPSA::has_campaignid() const {
+  return _internal_has_campaignid();
+}
+inline void StatusPSA::clear_campaignid() {
+  _impl_.campaignid_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t StatusPSA::_internal_campaignid() const {
+  return _impl_.campaignid_;
+}
+inline uint64_t StatusPSA::campaignid() const {
+  // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignId)
+  return _internal_campaignid();
+}
+inline void StatusPSA::_internal_set_campaignid(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.campaignid_ = value;
+}
+inline void StatusPSA::set_campaignid(uint64_t value) {
+  _internal_set_campaignid(value);
+  // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignId)
+}
+
+// optional uint64 campaignExpirationTimestamp = 45;
+inline bool StatusPSA::_internal_has_campaignexpirationtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool StatusPSA::has_campaignexpirationtimestamp() const {
+  return _internal_has_campaignexpirationtimestamp();
+}
+inline void StatusPSA::clear_campaignexpirationtimestamp() {
+  _impl_.campaignexpirationtimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t StatusPSA::_internal_campaignexpirationtimestamp() const {
+  return _impl_.campaignexpirationtimestamp_;
+}
+inline uint64_t StatusPSA::campaignexpirationtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignExpirationTimestamp)
+  return _internal_campaignexpirationtimestamp();
+}
+inline void StatusPSA::_internal_set_campaignexpirationtimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.campaignexpirationtimestamp_ = value;
+}
+inline void StatusPSA::set_campaignexpirationtimestamp(uint64_t value) {
+  _internal_set_campaignexpirationtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignExpirationTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// StickerMetadata
+
+// optional string url = 1;
+inline bool StickerMetadata::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_url() const {
+  return _internal_has_url();
+}
+inline void StickerMetadata::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& StickerMetadata::url() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.url)
+}
+inline std::string* StickerMetadata::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.url)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void StickerMetadata::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_url() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.url)
+}
+
+// optional bytes fileSha256 = 2;
+inline bool StickerMetadata::_internal_has_filesha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_filesha256() const {
+  return _internal_has_filesha256();
+}
+inline void StickerMetadata::clear_filesha256() {
+  _impl_.filesha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& StickerMetadata::filesha256() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileSha256)
+  return _internal_filesha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_filesha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileSha256)
+}
+inline std::string* StickerMetadata::mutable_filesha256() {
+  std::string* _s = _internal_mutable_filesha256();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileSha256)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_filesha256() const {
+  return _impl_.filesha256_.Get();
+}
+inline void StickerMetadata::_internal_set_filesha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.filesha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_filesha256() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_filesha256() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileSha256)
+  if (!_internal_has_filesha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.filesha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_filesha256(std::string* filesha256) {
+  if (filesha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filesha256_.IsDefault()) {
+    _impl_.filesha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileSha256)
+}
+
+// optional bytes fileEncSha256 = 3;
+inline bool StickerMetadata::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void StickerMetadata::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& StickerMetadata::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileEncSha256)
+}
+inline std::string* StickerMetadata::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileEncSha256)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void StickerMetadata::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileEncSha256)
+}
+
+// optional bytes mediaKey = 4;
+inline bool StickerMetadata::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void StickerMetadata::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& StickerMetadata::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.mediaKey)
+}
+inline std::string* StickerMetadata::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mediaKey)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void StickerMetadata::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mediaKey)
+}
+
+// optional string mimetype = 5;
+inline bool StickerMetadata::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void StickerMetadata::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& StickerMetadata::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.mimetype)
+}
+inline std::string* StickerMetadata::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mimetype)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void StickerMetadata::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mimetype)
+}
+
+// optional uint32 height = 6;
+inline bool StickerMetadata::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_height() const {
+  return _internal_has_height();
+}
+inline void StickerMetadata::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint32_t StickerMetadata::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t StickerMetadata::height() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.height)
+  return _internal_height();
+}
+inline void StickerMetadata::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.height_ = value;
+}
+inline void StickerMetadata::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.height)
+}
+
+// optional uint32 width = 7;
+inline bool StickerMetadata::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_width() const {
+  return _internal_has_width();
+}
+inline void StickerMetadata::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint32_t StickerMetadata::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t StickerMetadata::width() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.width)
+  return _internal_width();
+}
+inline void StickerMetadata::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.width_ = value;
+}
+inline void StickerMetadata::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.width)
+}
+
+// optional string directPath = 8;
+inline bool StickerMetadata::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void StickerMetadata::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& StickerMetadata::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StickerMetadata::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.directPath)
+}
+inline std::string* StickerMetadata::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.directPath)
+  return _s;
+}
+inline const std::string& StickerMetadata::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void StickerMetadata::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StickerMetadata::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.StickerMetadata.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void StickerMetadata::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.directPath)
+}
+
+// optional uint64 fileLength = 9;
+inline bool StickerMetadata::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void StickerMetadata::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline uint64_t StickerMetadata::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t StickerMetadata::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileLength)
+  return _internal_filelength();
+}
+inline void StickerMetadata::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.filelength_ = value;
+}
+inline void StickerMetadata::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileLength)
+}
+
+// optional float weight = 10;
+inline bool StickerMetadata::_internal_has_weight() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool StickerMetadata::has_weight() const {
+  return _internal_has_weight();
+}
+inline void StickerMetadata::clear_weight() {
+  _impl_.weight_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline float StickerMetadata::_internal_weight() const {
+  return _impl_.weight_;
+}
+inline float StickerMetadata::weight() const {
+  // @@protoc_insertion_point(field_get:proto.StickerMetadata.weight)
+  return _internal_weight();
+}
+inline void StickerMetadata::_internal_set_weight(float value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.weight_ = value;
+}
+inline void StickerMetadata::set_weight(float value) {
+  _internal_set_weight(value);
+  // @@protoc_insertion_point(field_set:proto.StickerMetadata.weight)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionData
+
+// optional bytes index = 1;
+inline bool SyncActionData::_internal_has_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionData::has_index() const {
+  return _internal_has_index();
+}
+inline void SyncActionData::clear_index() {
+  _impl_.index_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionData::index() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionData.index)
+  return _internal_index();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionData::set_index(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.index_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionData.index)
+}
+inline std::string* SyncActionData::mutable_index() {
+  std::string* _s = _internal_mutable_index();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.index)
+  return _s;
+}
+inline const std::string& SyncActionData::_internal_index() const {
+  return _impl_.index_.Get();
+}
+inline void SyncActionData::_internal_set_index(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.index_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionData::_internal_mutable_index() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.index_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionData::release_index() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionData.index)
+  if (!_internal_has_index()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.index_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.index_.IsDefault()) {
+    _impl_.index_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionData::set_allocated_index(std::string* index) {
+  if (index != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.index_.SetAllocated(index, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.index_.IsDefault()) {
+    _impl_.index_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.index)
+}
+
+// optional .proto.SyncActionValue value = 2;
+inline bool SyncActionData::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
+  return value;
+}
+inline bool SyncActionData::has_value() const {
+  return _internal_has_value();
+}
+inline void SyncActionData::clear_value() {
+  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::SyncActionValue& SyncActionData::_internal_value() const {
+  const ::proto::SyncActionValue* p = _impl_.value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue&>(
+      ::proto::_SyncActionValue_default_instance_);
+}
+inline const ::proto::SyncActionValue& SyncActionData::value() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionData.value)
+  return _internal_value();
+}
+inline void SyncActionData::unsafe_arena_set_allocated_value(
+    ::proto::SyncActionValue* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  _impl_.value_ = value;
+  if (value) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionData.value)
+}
+inline ::proto::SyncActionValue* SyncActionData::release_value() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncActionValue* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue* SyncActionData::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionData.value)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncActionValue* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue* SyncActionData::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue>(GetArenaForAllocation());
+    _impl_.value_ = p;
+  }
+  return _impl_.value_;
+}
+inline ::proto::SyncActionValue* SyncActionData::mutable_value() {
+  ::proto::SyncActionValue* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.value)
+  return _msg;
+}
+inline void SyncActionData::set_allocated_value(::proto::SyncActionValue* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.value)
+}
+
+// optional bytes padding = 3;
+inline bool SyncActionData::_internal_has_padding() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionData::has_padding() const {
+  return _internal_has_padding();
+}
+inline void SyncActionData::clear_padding() {
+  _impl_.padding_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SyncActionData::padding() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionData.padding)
+  return _internal_padding();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionData::set_padding(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.padding_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionData.padding)
+}
+inline std::string* SyncActionData::mutable_padding() {
+  std::string* _s = _internal_mutable_padding();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.padding)
+  return _s;
+}
+inline const std::string& SyncActionData::_internal_padding() const {
+  return _impl_.padding_.Get();
+}
+inline void SyncActionData::_internal_set_padding(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.padding_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionData::_internal_mutable_padding() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.padding_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionData::release_padding() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionData.padding)
+  if (!_internal_has_padding()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.padding_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.padding_.IsDefault()) {
+    _impl_.padding_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionData::set_allocated_padding(std::string* padding) {
+  if (padding != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.padding_.SetAllocated(padding, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.padding_.IsDefault()) {
+    _impl_.padding_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.padding)
+}
+
+// optional int32 version = 4;
+inline bool SyncActionData::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SyncActionData::has_version() const {
+  return _internal_has_version();
+}
+inline void SyncActionData::clear_version() {
+  _impl_.version_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t SyncActionData::_internal_version() const {
+  return _impl_.version_;
+}
+inline int32_t SyncActionData::version() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionData.version)
+  return _internal_version();
+}
+inline void SyncActionData::_internal_set_version(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.version_ = value;
+}
+inline void SyncActionData::set_version(int32_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionData.version)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_AgentAction
+
+// optional string name = 1;
+inline bool SyncActionValue_AgentAction::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_AgentAction::has_name() const {
+  return _internal_has_name();
+}
+inline void SyncActionValue_AgentAction::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_AgentAction::name() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_AgentAction::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.name)
+}
+inline std::string* SyncActionValue_AgentAction::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.AgentAction.name)
+  return _s;
+}
+inline const std::string& SyncActionValue_AgentAction::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void SyncActionValue_AgentAction::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_AgentAction::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_AgentAction::release_name() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.AgentAction.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_AgentAction::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.AgentAction.name)
+}
+
+// optional int32 deviceID = 2;
+inline bool SyncActionValue_AgentAction::_internal_has_deviceid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_AgentAction::has_deviceid() const {
+  return _internal_has_deviceid();
+}
+inline void SyncActionValue_AgentAction::clear_deviceid() {
+  _impl_.deviceid_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t SyncActionValue_AgentAction::_internal_deviceid() const {
+  return _impl_.deviceid_;
+}
+inline int32_t SyncActionValue_AgentAction::deviceid() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.deviceID)
+  return _internal_deviceid();
+}
+inline void SyncActionValue_AgentAction::_internal_set_deviceid(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.deviceid_ = value;
+}
+inline void SyncActionValue_AgentAction::set_deviceid(int32_t value) {
+  _internal_set_deviceid(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.deviceID)
+}
+
+// optional bool isDeleted = 3;
+inline bool SyncActionValue_AgentAction::_internal_has_isdeleted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SyncActionValue_AgentAction::has_isdeleted() const {
+  return _internal_has_isdeleted();
+}
+inline void SyncActionValue_AgentAction::clear_isdeleted() {
+  _impl_.isdeleted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool SyncActionValue_AgentAction::_internal_isdeleted() const {
+  return _impl_.isdeleted_;
+}
+inline bool SyncActionValue_AgentAction::isdeleted() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.isDeleted)
+  return _internal_isdeleted();
+}
+inline void SyncActionValue_AgentAction::_internal_set_isdeleted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.isdeleted_ = value;
+}
+inline void SyncActionValue_AgentAction::set_isdeleted(bool value) {
+  _internal_set_isdeleted(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.isDeleted)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_AndroidUnsupportedActions
+
+// optional bool allowed = 1;
+inline bool SyncActionValue_AndroidUnsupportedActions::_internal_has_allowed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_AndroidUnsupportedActions::has_allowed() const {
+  return _internal_has_allowed();
+}
+inline void SyncActionValue_AndroidUnsupportedActions::clear_allowed() {
+  _impl_.allowed_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_AndroidUnsupportedActions::_internal_allowed() const {
+  return _impl_.allowed_;
+}
+inline bool SyncActionValue_AndroidUnsupportedActions::allowed() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AndroidUnsupportedActions.allowed)
+  return _internal_allowed();
+}
+inline void SyncActionValue_AndroidUnsupportedActions::_internal_set_allowed(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.allowed_ = value;
+}
+inline void SyncActionValue_AndroidUnsupportedActions::set_allowed(bool value) {
+  _internal_set_allowed(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AndroidUnsupportedActions.allowed)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_ArchiveChatAction
+
+// optional bool archived = 1;
+inline bool SyncActionValue_ArchiveChatAction::_internal_has_archived() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_ArchiveChatAction::has_archived() const {
+  return _internal_has_archived();
+}
+inline void SyncActionValue_ArchiveChatAction::clear_archived() {
+  _impl_.archived_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool SyncActionValue_ArchiveChatAction::_internal_archived() const {
+  return _impl_.archived_;
+}
+inline bool SyncActionValue_ArchiveChatAction::archived() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.archived)
+  return _internal_archived();
+}
+inline void SyncActionValue_ArchiveChatAction::_internal_set_archived(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.archived_ = value;
+}
+inline void SyncActionValue_ArchiveChatAction::set_archived(bool value) {
+  _internal_set_archived(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ArchiveChatAction.archived)
+}
+
+// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+inline bool SyncActionValue_ArchiveChatAction::_internal_has_messagerange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue_ArchiveChatAction::has_messagerange() const {
+  return _internal_has_messagerange();
+}
+inline void SyncActionValue_ArchiveChatAction::clear_messagerange() {
+  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::_internal_messagerange() const {
+  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
+      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::messagerange() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.messageRange)
+  return _internal_messagerange();
+}
+inline void SyncActionValue_ArchiveChatAction::unsafe_arena_set_allocated_messagerange(
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
+  }
+  _impl_.messagerange_ = messagerange;
+  if (messagerange) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange)
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::release_messagerange() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::unsafe_arena_release_messagerange() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ArchiveChatAction.messageRange)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::_internal_mutable_messagerange() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.messagerange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
+    _impl_.messagerange_ = p;
+  }
+  return _impl_.messagerange_;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::mutable_messagerange() {
+  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ArchiveChatAction.messageRange)
+  return _msg;
+}
+inline void SyncActionValue_ArchiveChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.messagerange_;
+  }
+  if (messagerange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
+    if (message_arena != submessage_arena) {
+      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, messagerange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messagerange_ = messagerange;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_ClearChatAction
+
+// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+inline bool SyncActionValue_ClearChatAction::_internal_has_messagerange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue_ClearChatAction::has_messagerange() const {
+  return _internal_has_messagerange();
+}
+inline void SyncActionValue_ClearChatAction::clear_messagerange() {
+  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::_internal_messagerange() const {
+  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
+      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::messagerange() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ClearChatAction.messageRange)
+  return _internal_messagerange();
+}
+inline void SyncActionValue_ClearChatAction::unsafe_arena_set_allocated_messagerange(
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
+  }
+  _impl_.messagerange_ = messagerange;
+  if (messagerange) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange)
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::release_messagerange() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::unsafe_arena_release_messagerange() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ClearChatAction.messageRange)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::_internal_mutable_messagerange() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.messagerange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
+    _impl_.messagerange_ = p;
+  }
+  return _impl_.messagerange_;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::mutable_messagerange() {
+  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ClearChatAction.messageRange)
+  return _msg;
+}
+inline void SyncActionValue_ClearChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.messagerange_;
+  }
+  if (messagerange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
+    if (message_arena != submessage_arena) {
+      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, messagerange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messagerange_ = messagerange;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_ContactAction
+
+// optional string fullName = 1;
+inline bool SyncActionValue_ContactAction::_internal_has_fullname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_ContactAction::has_fullname() const {
+  return _internal_has_fullname();
+}
+inline void SyncActionValue_ContactAction::clear_fullname() {
+  _impl_.fullname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_ContactAction::fullname() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.fullName)
+  return _internal_fullname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_ContactAction::set_fullname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.fullname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.fullName)
+}
+inline std::string* SyncActionValue_ContactAction::mutable_fullname() {
+  std::string* _s = _internal_mutable_fullname();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.fullName)
+  return _s;
+}
+inline const std::string& SyncActionValue_ContactAction::_internal_fullname() const {
+  return _impl_.fullname_.Get();
+}
+inline void SyncActionValue_ContactAction::_internal_set_fullname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.fullname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_ContactAction::_internal_mutable_fullname() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.fullname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_ContactAction::release_fullname() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.fullName)
+  if (!_internal_has_fullname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.fullname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fullname_.IsDefault()) {
+    _impl_.fullname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_ContactAction::set_allocated_fullname(std::string* fullname) {
+  if (fullname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.fullname_.SetAllocated(fullname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fullname_.IsDefault()) {
+    _impl_.fullname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.fullName)
+}
+
+// optional string firstName = 2;
+inline bool SyncActionValue_ContactAction::_internal_has_firstname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_ContactAction::has_firstname() const {
+  return _internal_has_firstname();
+}
+inline void SyncActionValue_ContactAction::clear_firstname() {
+  _impl_.firstname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SyncActionValue_ContactAction::firstname() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.firstName)
+  return _internal_firstname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_ContactAction::set_firstname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.firstname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.firstName)
+}
+inline std::string* SyncActionValue_ContactAction::mutable_firstname() {
+  std::string* _s = _internal_mutable_firstname();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.firstName)
+  return _s;
+}
+inline const std::string& SyncActionValue_ContactAction::_internal_firstname() const {
+  return _impl_.firstname_.Get();
+}
+inline void SyncActionValue_ContactAction::_internal_set_firstname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.firstname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_ContactAction::_internal_mutable_firstname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.firstname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_ContactAction::release_firstname() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.firstName)
+  if (!_internal_has_firstname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.firstname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstname_.IsDefault()) {
+    _impl_.firstname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_ContactAction::set_allocated_firstname(std::string* firstname) {
+  if (firstname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.firstname_.SetAllocated(firstname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.firstname_.IsDefault()) {
+    _impl_.firstname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.firstName)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_DeleteChatAction
+
+// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
+inline bool SyncActionValue_DeleteChatAction::_internal_has_messagerange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue_DeleteChatAction::has_messagerange() const {
+  return _internal_has_messagerange();
+}
+inline void SyncActionValue_DeleteChatAction::clear_messagerange() {
+  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::_internal_messagerange() const {
+  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
+      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::messagerange() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteChatAction.messageRange)
+  return _internal_messagerange();
+}
+inline void SyncActionValue_DeleteChatAction::unsafe_arena_set_allocated_messagerange(
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
+  }
+  _impl_.messagerange_ = messagerange;
+  if (messagerange) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange)
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::release_messagerange() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::unsafe_arena_release_messagerange() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.DeleteChatAction.messageRange)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::_internal_mutable_messagerange() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.messagerange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
+    _impl_.messagerange_ = p;
+  }
+  return _impl_.messagerange_;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::mutable_messagerange() {
+  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.DeleteChatAction.messageRange)
+  return _msg;
+}
+inline void SyncActionValue_DeleteChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.messagerange_;
+  }
+  if (messagerange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
+    if (message_arena != submessage_arena) {
+      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, messagerange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messagerange_ = messagerange;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_DeleteMessageForMeAction
+
+// optional bool deleteMedia = 1;
+inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_deletemedia() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_DeleteMessageForMeAction::has_deletemedia() const {
+  return _internal_has_deletemedia();
+}
+inline void SyncActionValue_DeleteMessageForMeAction::clear_deletemedia() {
+  _impl_.deletemedia_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool SyncActionValue_DeleteMessageForMeAction::_internal_deletemedia() const {
+  return _impl_.deletemedia_;
+}
+inline bool SyncActionValue_DeleteMessageForMeAction::deletemedia() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia)
+  return _internal_deletemedia();
+}
+inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_deletemedia(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.deletemedia_ = value;
+}
+inline void SyncActionValue_DeleteMessageForMeAction::set_deletemedia(bool value) {
+  _internal_set_deletemedia(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia)
+}
+
+// optional int64 messageTimestamp = 2;
+inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_messagetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_DeleteMessageForMeAction::has_messagetimestamp() const {
+  return _internal_has_messagetimestamp();
+}
+inline void SyncActionValue_DeleteMessageForMeAction::clear_messagetimestamp() {
+  _impl_.messagetimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t SyncActionValue_DeleteMessageForMeAction::_internal_messagetimestamp() const {
+  return _impl_.messagetimestamp_;
+}
+inline int64_t SyncActionValue_DeleteMessageForMeAction::messagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp)
+  return _internal_messagetimestamp();
+}
+inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_messagetimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.messagetimestamp_ = value;
+}
+inline void SyncActionValue_DeleteMessageForMeAction::set_messagetimestamp(int64_t value) {
+  _internal_set_messagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_KeyExpiration
+
+// optional int32 expiredKeyEpoch = 1;
+inline bool SyncActionValue_KeyExpiration::_internal_has_expiredkeyepoch() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_KeyExpiration::has_expiredkeyepoch() const {
+  return _internal_has_expiredkeyepoch();
+}
+inline void SyncActionValue_KeyExpiration::clear_expiredkeyepoch() {
+  _impl_.expiredkeyepoch_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t SyncActionValue_KeyExpiration::_internal_expiredkeyepoch() const {
+  return _impl_.expiredkeyepoch_;
+}
+inline int32_t SyncActionValue_KeyExpiration::expiredkeyepoch() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch)
+  return _internal_expiredkeyepoch();
+}
+inline void SyncActionValue_KeyExpiration::_internal_set_expiredkeyepoch(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.expiredkeyepoch_ = value;
+}
+inline void SyncActionValue_KeyExpiration::set_expiredkeyepoch(int32_t value) {
+  _internal_set_expiredkeyepoch(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_LabelAssociationAction
+
+// optional bool labeled = 1;
+inline bool SyncActionValue_LabelAssociationAction::_internal_has_labeled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LabelAssociationAction::has_labeled() const {
+  return _internal_has_labeled();
+}
+inline void SyncActionValue_LabelAssociationAction::clear_labeled() {
+  _impl_.labeled_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_LabelAssociationAction::_internal_labeled() const {
+  return _impl_.labeled_;
+}
+inline bool SyncActionValue_LabelAssociationAction::labeled() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelAssociationAction.labeled)
+  return _internal_labeled();
+}
+inline void SyncActionValue_LabelAssociationAction::_internal_set_labeled(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.labeled_ = value;
+}
+inline void SyncActionValue_LabelAssociationAction::set_labeled(bool value) {
+  _internal_set_labeled(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelAssociationAction.labeled)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_LabelEditAction
+
+// optional string name = 1;
+inline bool SyncActionValue_LabelEditAction::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LabelEditAction::has_name() const {
+  return _internal_has_name();
+}
+inline void SyncActionValue_LabelEditAction::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_LabelEditAction::name() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_LabelEditAction::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.name)
+}
+inline std::string* SyncActionValue_LabelEditAction::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LabelEditAction.name)
+  return _s;
+}
+inline const std::string& SyncActionValue_LabelEditAction::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void SyncActionValue_LabelEditAction::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_LabelEditAction::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_LabelEditAction::release_name() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.LabelEditAction.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_LabelEditAction::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LabelEditAction.name)
+}
+
+// optional int32 color = 2;
+inline bool SyncActionValue_LabelEditAction::_internal_has_color() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LabelEditAction::has_color() const {
+  return _internal_has_color();
+}
+inline void SyncActionValue_LabelEditAction::clear_color() {
+  _impl_.color_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t SyncActionValue_LabelEditAction::_internal_color() const {
+  return _impl_.color_;
+}
+inline int32_t SyncActionValue_LabelEditAction::color() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.color)
+  return _internal_color();
+}
+inline void SyncActionValue_LabelEditAction::_internal_set_color(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.color_ = value;
+}
+inline void SyncActionValue_LabelEditAction::set_color(int32_t value) {
+  _internal_set_color(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.color)
+}
+
+// optional int32 predefinedId = 3;
+inline bool SyncActionValue_LabelEditAction::_internal_has_predefinedid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LabelEditAction::has_predefinedid() const {
+  return _internal_has_predefinedid();
+}
+inline void SyncActionValue_LabelEditAction::clear_predefinedid() {
+  _impl_.predefinedid_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t SyncActionValue_LabelEditAction::_internal_predefinedid() const {
+  return _impl_.predefinedid_;
+}
+inline int32_t SyncActionValue_LabelEditAction::predefinedid() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.predefinedId)
+  return _internal_predefinedid();
+}
+inline void SyncActionValue_LabelEditAction::_internal_set_predefinedid(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.predefinedid_ = value;
+}
+inline void SyncActionValue_LabelEditAction::set_predefinedid(int32_t value) {
+  _internal_set_predefinedid(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.predefinedId)
+}
+
+// optional bool deleted = 4;
+inline bool SyncActionValue_LabelEditAction::_internal_has_deleted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LabelEditAction::has_deleted() const {
+  return _internal_has_deleted();
+}
+inline void SyncActionValue_LabelEditAction::clear_deleted() {
+  _impl_.deleted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool SyncActionValue_LabelEditAction::_internal_deleted() const {
+  return _impl_.deleted_;
+}
+inline bool SyncActionValue_LabelEditAction::deleted() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.deleted)
+  return _internal_deleted();
+}
+inline void SyncActionValue_LabelEditAction::_internal_set_deleted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.deleted_ = value;
+}
+inline void SyncActionValue_LabelEditAction::set_deleted(bool value) {
+  _internal_set_deleted(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.deleted)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_LocaleSetting
+
+// optional string locale = 1;
+inline bool SyncActionValue_LocaleSetting::_internal_has_locale() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_LocaleSetting::has_locale() const {
+  return _internal_has_locale();
+}
+inline void SyncActionValue_LocaleSetting::clear_locale() {
+  _impl_.locale_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_LocaleSetting::locale() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LocaleSetting.locale)
+  return _internal_locale();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_LocaleSetting::set_locale(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.locale_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LocaleSetting.locale)
+}
+inline std::string* SyncActionValue_LocaleSetting::mutable_locale() {
+  std::string* _s = _internal_mutable_locale();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LocaleSetting.locale)
+  return _s;
+}
+inline const std::string& SyncActionValue_LocaleSetting::_internal_locale() const {
+  return _impl_.locale_.Get();
+}
+inline void SyncActionValue_LocaleSetting::_internal_set_locale(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.locale_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_LocaleSetting::_internal_mutable_locale() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.locale_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_LocaleSetting::release_locale() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.LocaleSetting.locale)
+  if (!_internal_has_locale()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.locale_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.locale_.IsDefault()) {
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_LocaleSetting::set_allocated_locale(std::string* locale) {
+  if (locale != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.locale_.SetAllocated(locale, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.locale_.IsDefault()) {
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LocaleSetting.locale)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_MarkChatAsReadAction
+
+// optional bool read = 1;
+inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_read() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_MarkChatAsReadAction::has_read() const {
+  return _internal_has_read();
+}
+inline void SyncActionValue_MarkChatAsReadAction::clear_read() {
+  _impl_.read_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool SyncActionValue_MarkChatAsReadAction::_internal_read() const {
+  return _impl_.read_;
+}
+inline bool SyncActionValue_MarkChatAsReadAction::read() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.read)
+  return _internal_read();
+}
+inline void SyncActionValue_MarkChatAsReadAction::_internal_set_read(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.read_ = value;
+}
+inline void SyncActionValue_MarkChatAsReadAction::set_read(bool value) {
+  _internal_set_read(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MarkChatAsReadAction.read)
+}
+
+// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
+inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_messagerange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue_MarkChatAsReadAction::has_messagerange() const {
+  return _internal_has_messagerange();
+}
+inline void SyncActionValue_MarkChatAsReadAction::clear_messagerange() {
+  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::_internal_messagerange() const {
+  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
+      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
+}
+inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::messagerange() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
+  return _internal_messagerange();
+}
+inline void SyncActionValue_MarkChatAsReadAction::unsafe_arena_set_allocated_messagerange(
+    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
+  }
+  _impl_.messagerange_ = messagerange;
+  if (messagerange) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::release_messagerange() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::unsafe_arena_release_messagerange() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
+  _impl_.messagerange_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::_internal_mutable_messagerange() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.messagerange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
+    _impl_.messagerange_ = p;
+  }
+  return _impl_.messagerange_;
+}
+inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::mutable_messagerange() {
+  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
+  return _msg;
+}
+inline void SyncActionValue_MarkChatAsReadAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.messagerange_;
+  }
+  if (messagerange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
+    if (message_arena != submessage_arena) {
+      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, messagerange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.messagerange_ = messagerange;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_MuteAction
+
+// optional bool muted = 1;
+inline bool SyncActionValue_MuteAction::_internal_has_muted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_MuteAction::has_muted() const {
+  return _internal_has_muted();
+}
+inline void SyncActionValue_MuteAction::clear_muted() {
+  _impl_.muted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool SyncActionValue_MuteAction::_internal_muted() const {
+  return _impl_.muted_;
+}
+inline bool SyncActionValue_MuteAction::muted() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muted)
+  return _internal_muted();
+}
+inline void SyncActionValue_MuteAction::_internal_set_muted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.muted_ = value;
+}
+inline void SyncActionValue_MuteAction::set_muted(bool value) {
+  _internal_set_muted(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muted)
+}
+
+// optional int64 muteEndTimestamp = 2;
+inline bool SyncActionValue_MuteAction::_internal_has_muteendtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_MuteAction::has_muteendtimestamp() const {
+  return _internal_has_muteendtimestamp();
+}
+inline void SyncActionValue_MuteAction::clear_muteendtimestamp() {
+  _impl_.muteendtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t SyncActionValue_MuteAction::_internal_muteendtimestamp() const {
+  return _impl_.muteendtimestamp_;
+}
+inline int64_t SyncActionValue_MuteAction::muteendtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muteEndTimestamp)
+  return _internal_muteendtimestamp();
+}
+inline void SyncActionValue_MuteAction::_internal_set_muteendtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.muteendtimestamp_ = value;
+}
+inline void SyncActionValue_MuteAction::set_muteendtimestamp(int64_t value) {
+  _internal_set_muteendtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muteEndTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_NuxAction
+
+// optional bool acknowledged = 1;
+inline bool SyncActionValue_NuxAction::_internal_has_acknowledged() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_NuxAction::has_acknowledged() const {
+  return _internal_has_acknowledged();
+}
+inline void SyncActionValue_NuxAction::clear_acknowledged() {
+  _impl_.acknowledged_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_NuxAction::_internal_acknowledged() const {
+  return _impl_.acknowledged_;
+}
+inline bool SyncActionValue_NuxAction::acknowledged() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.NuxAction.acknowledged)
+  return _internal_acknowledged();
+}
+inline void SyncActionValue_NuxAction::_internal_set_acknowledged(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.acknowledged_ = value;
+}
+inline void SyncActionValue_NuxAction::set_acknowledged(bool value) {
+  _internal_set_acknowledged(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.NuxAction.acknowledged)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_PinAction
+
+// optional bool pinned = 1;
+inline bool SyncActionValue_PinAction::_internal_has_pinned() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_PinAction::has_pinned() const {
+  return _internal_has_pinned();
+}
+inline void SyncActionValue_PinAction::clear_pinned() {
+  _impl_.pinned_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_PinAction::_internal_pinned() const {
+  return _impl_.pinned_;
+}
+inline bool SyncActionValue_PinAction::pinned() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PinAction.pinned)
+  return _internal_pinned();
+}
+inline void SyncActionValue_PinAction::_internal_set_pinned(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.pinned_ = value;
+}
+inline void SyncActionValue_PinAction::set_pinned(bool value) {
+  _internal_set_pinned(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PinAction.pinned)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_PrimaryFeature
+
+// repeated string flags = 1;
+inline int SyncActionValue_PrimaryFeature::_internal_flags_size() const {
+  return _impl_.flags_.size();
+}
+inline int SyncActionValue_PrimaryFeature::flags_size() const {
+  return _internal_flags_size();
+}
+inline void SyncActionValue_PrimaryFeature::clear_flags() {
+  _impl_.flags_.Clear();
+}
+inline std::string* SyncActionValue_PrimaryFeature::add_flags() {
+  std::string* _s = _internal_add_flags();
+  // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.PrimaryFeature.flags)
+  return _s;
+}
+inline const std::string& SyncActionValue_PrimaryFeature::_internal_flags(int index) const {
+  return _impl_.flags_.Get(index);
+}
+inline const std::string& SyncActionValue_PrimaryFeature::flags(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryFeature.flags)
+  return _internal_flags(index);
+}
+inline std::string* SyncActionValue_PrimaryFeature::mutable_flags(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryFeature.flags)
+  return _impl_.flags_.Mutable(index);
+}
+inline void SyncActionValue_PrimaryFeature::set_flags(int index, const std::string& value) {
+  _impl_.flags_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::set_flags(int index, std::string&& value) {
+  _impl_.flags_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.flags_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value, size_t size) {
+  _impl_.flags_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline std::string* SyncActionValue_PrimaryFeature::_internal_add_flags() {
+  return _impl_.flags_.Add();
+}
+inline void SyncActionValue_PrimaryFeature::add_flags(const std::string& value) {
+  _impl_.flags_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::add_flags(std::string&& value) {
+  _impl_.flags_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::add_flags(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.flags_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline void SyncActionValue_PrimaryFeature::add_flags(const char* value, size_t size) {
+  _impl_.flags_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.PrimaryFeature.flags)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SyncActionValue_PrimaryFeature::flags() const {
+  // @@protoc_insertion_point(field_list:proto.SyncActionValue.PrimaryFeature.flags)
+  return _impl_.flags_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SyncActionValue_PrimaryFeature::mutable_flags() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.PrimaryFeature.flags)
+  return &_impl_.flags_;
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_PrimaryVersionAction
+
+// optional string version = 1;
+inline bool SyncActionValue_PrimaryVersionAction::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_PrimaryVersionAction::has_version() const {
+  return _internal_has_version();
+}
+inline void SyncActionValue_PrimaryVersionAction::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_PrimaryVersionAction::version() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryVersionAction.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_PrimaryVersionAction::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryVersionAction.version)
+}
+inline std::string* SyncActionValue_PrimaryVersionAction::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryVersionAction.version)
+  return _s;
+}
+inline const std::string& SyncActionValue_PrimaryVersionAction::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void SyncActionValue_PrimaryVersionAction::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_PrimaryVersionAction::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_PrimaryVersionAction::release_version() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.PrimaryVersionAction.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_PrimaryVersionAction::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PrimaryVersionAction.version)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_PushNameSetting
+
+// optional string name = 1;
+inline bool SyncActionValue_PushNameSetting::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_PushNameSetting::has_name() const {
+  return _internal_has_name();
+}
+inline void SyncActionValue_PushNameSetting::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_PushNameSetting::name() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PushNameSetting.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_PushNameSetting::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PushNameSetting.name)
+}
+inline std::string* SyncActionValue_PushNameSetting::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PushNameSetting.name)
+  return _s;
+}
+inline const std::string& SyncActionValue_PushNameSetting::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void SyncActionValue_PushNameSetting::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_PushNameSetting::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_PushNameSetting::release_name() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.PushNameSetting.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_PushNameSetting::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PushNameSetting.name)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_QuickReplyAction
+
+// optional string shortcut = 1;
+inline bool SyncActionValue_QuickReplyAction::_internal_has_shortcut() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_QuickReplyAction::has_shortcut() const {
+  return _internal_has_shortcut();
+}
+inline void SyncActionValue_QuickReplyAction::clear_shortcut() {
+  _impl_.shortcut_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_QuickReplyAction::shortcut() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.shortcut)
+  return _internal_shortcut();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_QuickReplyAction::set_shortcut(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.shortcut_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.shortcut)
+}
+inline std::string* SyncActionValue_QuickReplyAction::mutable_shortcut() {
+  std::string* _s = _internal_mutable_shortcut();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.shortcut)
+  return _s;
+}
+inline const std::string& SyncActionValue_QuickReplyAction::_internal_shortcut() const {
+  return _impl_.shortcut_.Get();
+}
+inline void SyncActionValue_QuickReplyAction::_internal_set_shortcut(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.shortcut_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_shortcut() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.shortcut_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_QuickReplyAction::release_shortcut() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.shortcut)
+  if (!_internal_has_shortcut()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.shortcut_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.shortcut_.IsDefault()) {
+    _impl_.shortcut_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_QuickReplyAction::set_allocated_shortcut(std::string* shortcut) {
+  if (shortcut != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.shortcut_.SetAllocated(shortcut, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.shortcut_.IsDefault()) {
+    _impl_.shortcut_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.shortcut)
+}
+
+// optional string message = 2;
+inline bool SyncActionValue_QuickReplyAction::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_QuickReplyAction::has_message() const {
+  return _internal_has_message();
+}
+inline void SyncActionValue_QuickReplyAction::clear_message() {
+  _impl_.message_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SyncActionValue_QuickReplyAction::message() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.message)
+  return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_QuickReplyAction::set_message(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.message)
+}
+inline std::string* SyncActionValue_QuickReplyAction::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.message)
+  return _s;
+}
+inline const std::string& SyncActionValue_QuickReplyAction::_internal_message() const {
+  return _impl_.message_.Get();
+}
+inline void SyncActionValue_QuickReplyAction::_internal_set_message(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.message_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.message_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_QuickReplyAction::release_message() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.message)
+  if (!_internal_has_message()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.message_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_QuickReplyAction::set_allocated_message(std::string* message) {
+  if (message != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.message)
+}
+
+// repeated string keywords = 3;
+inline int SyncActionValue_QuickReplyAction::_internal_keywords_size() const {
+  return _impl_.keywords_.size();
+}
+inline int SyncActionValue_QuickReplyAction::keywords_size() const {
+  return _internal_keywords_size();
+}
+inline void SyncActionValue_QuickReplyAction::clear_keywords() {
+  _impl_.keywords_.Clear();
+}
+inline std::string* SyncActionValue_QuickReplyAction::add_keywords() {
+  std::string* _s = _internal_add_keywords();
+  // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.QuickReplyAction.keywords)
+  return _s;
+}
+inline const std::string& SyncActionValue_QuickReplyAction::_internal_keywords(int index) const {
+  return _impl_.keywords_.Get(index);
+}
+inline const std::string& SyncActionValue_QuickReplyAction::keywords(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.keywords)
+  return _internal_keywords(index);
+}
+inline std::string* SyncActionValue_QuickReplyAction::mutable_keywords(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.keywords)
+  return _impl_.keywords_.Mutable(index);
+}
+inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const std::string& value) {
+  _impl_.keywords_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::set_keywords(int index, std::string&& value) {
+  _impl_.keywords_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.keywords_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value, size_t size) {
+  _impl_.keywords_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline std::string* SyncActionValue_QuickReplyAction::_internal_add_keywords() {
+  return _impl_.keywords_.Add();
+}
+inline void SyncActionValue_QuickReplyAction::add_keywords(const std::string& value) {
+  _impl_.keywords_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::add_keywords(std::string&& value) {
+  _impl_.keywords_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.keywords_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value, size_t size) {
+  _impl_.keywords_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.QuickReplyAction.keywords)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SyncActionValue_QuickReplyAction::keywords() const {
+  // @@protoc_insertion_point(field_list:proto.SyncActionValue.QuickReplyAction.keywords)
+  return _impl_.keywords_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SyncActionValue_QuickReplyAction::mutable_keywords() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.QuickReplyAction.keywords)
+  return &_impl_.keywords_;
+}
+
+// optional int32 count = 4;
+inline bool SyncActionValue_QuickReplyAction::_internal_has_count() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SyncActionValue_QuickReplyAction::has_count() const {
+  return _internal_has_count();
+}
+inline void SyncActionValue_QuickReplyAction::clear_count() {
+  _impl_.count_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t SyncActionValue_QuickReplyAction::_internal_count() const {
+  return _impl_.count_;
+}
+inline int32_t SyncActionValue_QuickReplyAction::count() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.count)
+  return _internal_count();
+}
+inline void SyncActionValue_QuickReplyAction::_internal_set_count(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.count_ = value;
+}
+inline void SyncActionValue_QuickReplyAction::set_count(int32_t value) {
+  _internal_set_count(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.count)
+}
+
+// optional bool deleted = 5;
+inline bool SyncActionValue_QuickReplyAction::_internal_has_deleted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SyncActionValue_QuickReplyAction::has_deleted() const {
+  return _internal_has_deleted();
+}
+inline void SyncActionValue_QuickReplyAction::clear_deleted() {
+  _impl_.deleted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool SyncActionValue_QuickReplyAction::_internal_deleted() const {
+  return _impl_.deleted_;
+}
+inline bool SyncActionValue_QuickReplyAction::deleted() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.deleted)
+  return _internal_deleted();
+}
+inline void SyncActionValue_QuickReplyAction::_internal_set_deleted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.deleted_ = value;
+}
+inline void SyncActionValue_QuickReplyAction::set_deleted(bool value) {
+  _internal_set_deleted(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.deleted)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_RecentEmojiWeightsAction
+
+// repeated .proto.RecentEmojiWeight weights = 1;
+inline int SyncActionValue_RecentEmojiWeightsAction::_internal_weights_size() const {
+  return _impl_.weights_.size();
+}
+inline int SyncActionValue_RecentEmojiWeightsAction::weights_size() const {
+  return _internal_weights_size();
+}
+inline void SyncActionValue_RecentEmojiWeightsAction::clear_weights() {
+  _impl_.weights_.Clear();
+}
+inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::mutable_weights(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
+  return _impl_.weights_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >*
+SyncActionValue_RecentEmojiWeightsAction::mutable_weights() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
+  return &_impl_.weights_;
+}
+inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::_internal_weights(int index) const {
+  return _impl_.weights_.Get(index);
+}
+inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::weights(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
+  return _internal_weights(index);
+}
+inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::_internal_add_weights() {
+  return _impl_.weights_.Add();
+}
+inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::add_weights() {
+  ::proto::RecentEmojiWeight* _add = _internal_add_weights();
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >&
+SyncActionValue_RecentEmojiWeightsAction::weights() const {
+  // @@protoc_insertion_point(field_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
+  return _impl_.weights_;
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_SecurityNotificationSetting
+
+// optional bool showNotification = 1;
+inline bool SyncActionValue_SecurityNotificationSetting::_internal_has_shownotification() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SecurityNotificationSetting::has_shownotification() const {
+  return _internal_has_shownotification();
+}
+inline void SyncActionValue_SecurityNotificationSetting::clear_shownotification() {
+  _impl_.shownotification_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_SecurityNotificationSetting::_internal_shownotification() const {
+  return _impl_.shownotification_;
+}
+inline bool SyncActionValue_SecurityNotificationSetting::shownotification() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SecurityNotificationSetting.showNotification)
+  return _internal_shownotification();
+}
+inline void SyncActionValue_SecurityNotificationSetting::_internal_set_shownotification(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.shownotification_ = value;
+}
+inline void SyncActionValue_SecurityNotificationSetting::set_shownotification(bool value) {
+  _internal_set_shownotification(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SecurityNotificationSetting.showNotification)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_StarAction
+
+// optional bool starred = 1;
+inline bool SyncActionValue_StarAction::_internal_has_starred() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StarAction::has_starred() const {
+  return _internal_has_starred();
+}
+inline void SyncActionValue_StarAction::clear_starred() {
+  _impl_.starred_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_StarAction::_internal_starred() const {
+  return _impl_.starred_;
+}
+inline bool SyncActionValue_StarAction::starred() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StarAction.starred)
+  return _internal_starred();
+}
+inline void SyncActionValue_StarAction::_internal_set_starred(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.starred_ = value;
+}
+inline void SyncActionValue_StarAction::set_starred(bool value) {
+  _internal_set_starred(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StarAction.starred)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_StickerAction
+
+// optional string url = 1;
+inline bool SyncActionValue_StickerAction::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_url() const {
+  return _internal_has_url();
+}
+inline void SyncActionValue_StickerAction::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncActionValue_StickerAction::url() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_StickerAction::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.url)
+}
+inline std::string* SyncActionValue_StickerAction::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.url)
+  return _s;
+}
+inline const std::string& SyncActionValue_StickerAction::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void SyncActionValue_StickerAction::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::release_url() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_StickerAction::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.url)
+}
+
+// optional bytes fileEncSha256 = 2;
+inline bool SyncActionValue_StickerAction::_internal_has_fileencsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_fileencsha256() const {
+  return _internal_has_fileencsha256();
+}
+inline void SyncActionValue_StickerAction::clear_fileencsha256() {
+  _impl_.fileencsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SyncActionValue_StickerAction::fileencsha256() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileEncSha256)
+  return _internal_fileencsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_StickerAction::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileEncSha256)
+}
+inline std::string* SyncActionValue_StickerAction::mutable_fileencsha256() {
+  std::string* _s = _internal_mutable_fileencsha256();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.fileEncSha256)
+  return _s;
+}
+inline const std::string& SyncActionValue_StickerAction::_internal_fileencsha256() const {
+  return _impl_.fileencsha256_.Get();
+}
+inline void SyncActionValue_StickerAction::_internal_set_fileencsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::_internal_mutable_fileencsha256() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::release_fileencsha256() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.fileEncSha256)
+  if (!_internal_has_fileencsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.fileencsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_StickerAction::set_allocated_fileencsha256(std::string* fileencsha256) {
+  if (fileencsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.fileencsha256_.IsDefault()) {
+    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.fileEncSha256)
+}
+
+// optional bytes mediaKey = 3;
+inline bool SyncActionValue_StickerAction::_internal_has_mediakey() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_mediakey() const {
+  return _internal_has_mediakey();
+}
+inline void SyncActionValue_StickerAction::clear_mediakey() {
+  _impl_.mediakey_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SyncActionValue_StickerAction::mediakey() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mediaKey)
+  return _internal_mediakey();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_StickerAction::set_mediakey(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mediaKey)
+}
+inline std::string* SyncActionValue_StickerAction::mutable_mediakey() {
+  std::string* _s = _internal_mutable_mediakey();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mediaKey)
+  return _s;
+}
+inline const std::string& SyncActionValue_StickerAction::_internal_mediakey() const {
+  return _impl_.mediakey_.Get();
+}
+inline void SyncActionValue_StickerAction::_internal_set_mediakey(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.mediakey_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::_internal_mutable_mediakey() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::release_mediakey() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mediaKey)
+  if (!_internal_has_mediakey()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.mediakey_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_StickerAction::set_allocated_mediakey(std::string* mediakey) {
+  if (mediakey != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediakey_.IsDefault()) {
+    _impl_.mediakey_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mediaKey)
+}
+
+// optional string mimetype = 4;
+inline bool SyncActionValue_StickerAction::_internal_has_mimetype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_mimetype() const {
+  return _internal_has_mimetype();
+}
+inline void SyncActionValue_StickerAction::clear_mimetype() {
+  _impl_.mimetype_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SyncActionValue_StickerAction::mimetype() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mimetype)
+  return _internal_mimetype();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_StickerAction::set_mimetype(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mimetype)
+}
+inline std::string* SyncActionValue_StickerAction::mutable_mimetype() {
+  std::string* _s = _internal_mutable_mimetype();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mimetype)
+  return _s;
+}
+inline const std::string& SyncActionValue_StickerAction::_internal_mimetype() const {
+  return _impl_.mimetype_.Get();
+}
+inline void SyncActionValue_StickerAction::_internal_set_mimetype(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.mimetype_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::_internal_mutable_mimetype() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::release_mimetype() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mimetype)
+  if (!_internal_has_mimetype()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.mimetype_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_StickerAction::set_allocated_mimetype(std::string* mimetype) {
+  if (mimetype != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mimetype_.IsDefault()) {
+    _impl_.mimetype_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mimetype)
+}
+
+// optional uint32 height = 5;
+inline bool SyncActionValue_StickerAction::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_height() const {
+  return _internal_has_height();
+}
+inline void SyncActionValue_StickerAction::clear_height() {
+  _impl_.height_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint32_t SyncActionValue_StickerAction::_internal_height() const {
+  return _impl_.height_;
+}
+inline uint32_t SyncActionValue_StickerAction::height() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.height)
+  return _internal_height();
+}
+inline void SyncActionValue_StickerAction::_internal_set_height(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.height_ = value;
+}
+inline void SyncActionValue_StickerAction::set_height(uint32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.height)
+}
+
+// optional uint32 width = 6;
+inline bool SyncActionValue_StickerAction::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_width() const {
+  return _internal_has_width();
+}
+inline void SyncActionValue_StickerAction::clear_width() {
+  _impl_.width_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint32_t SyncActionValue_StickerAction::_internal_width() const {
+  return _impl_.width_;
+}
+inline uint32_t SyncActionValue_StickerAction::width() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.width)
+  return _internal_width();
+}
+inline void SyncActionValue_StickerAction::_internal_set_width(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.width_ = value;
+}
+inline void SyncActionValue_StickerAction::set_width(uint32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.width)
+}
+
+// optional string directPath = 7;
+inline bool SyncActionValue_StickerAction::_internal_has_directpath() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_directpath() const {
+  return _internal_has_directpath();
+}
+inline void SyncActionValue_StickerAction::clear_directpath() {
+  _impl_.directpath_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& SyncActionValue_StickerAction::directpath() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.directPath)
+  return _internal_directpath();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncActionValue_StickerAction::set_directpath(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.directPath)
+}
+inline std::string* SyncActionValue_StickerAction::mutable_directpath() {
+  std::string* _s = _internal_mutable_directpath();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.directPath)
+  return _s;
+}
+inline const std::string& SyncActionValue_StickerAction::_internal_directpath() const {
+  return _impl_.directpath_.Get();
+}
+inline void SyncActionValue_StickerAction::_internal_set_directpath(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.directpath_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::_internal_mutable_directpath() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.directpath_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncActionValue_StickerAction::release_directpath() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.directPath)
+  if (!_internal_has_directpath()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.directpath_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncActionValue_StickerAction::set_allocated_directpath(std::string* directpath) {
+  if (directpath != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directpath_.IsDefault()) {
+    _impl_.directpath_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.directPath)
+}
+
+// optional uint64 fileLength = 8;
+inline bool SyncActionValue_StickerAction::_internal_has_filelength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_filelength() const {
+  return _internal_has_filelength();
+}
+inline void SyncActionValue_StickerAction::clear_filelength() {
+  _impl_.filelength_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline uint64_t SyncActionValue_StickerAction::_internal_filelength() const {
+  return _impl_.filelength_;
+}
+inline uint64_t SyncActionValue_StickerAction::filelength() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileLength)
+  return _internal_filelength();
+}
+inline void SyncActionValue_StickerAction::_internal_set_filelength(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.filelength_ = value;
+}
+inline void SyncActionValue_StickerAction::set_filelength(uint64_t value) {
+  _internal_set_filelength(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileLength)
+}
+
+// optional bool isFavorite = 9;
+inline bool SyncActionValue_StickerAction::_internal_has_isfavorite() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_isfavorite() const {
+  return _internal_has_isfavorite();
+}
+inline void SyncActionValue_StickerAction::clear_isfavorite() {
+  _impl_.isfavorite_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool SyncActionValue_StickerAction::_internal_isfavorite() const {
+  return _impl_.isfavorite_;
+}
+inline bool SyncActionValue_StickerAction::isfavorite() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.isFavorite)
+  return _internal_isfavorite();
+}
+inline void SyncActionValue_StickerAction::_internal_set_isfavorite(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.isfavorite_ = value;
+}
+inline void SyncActionValue_StickerAction::set_isfavorite(bool value) {
+  _internal_set_isfavorite(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.isFavorite)
+}
+
+// optional uint32 deviceIdHint = 10;
+inline bool SyncActionValue_StickerAction::_internal_has_deviceidhint() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SyncActionValue_StickerAction::has_deviceidhint() const {
+  return _internal_has_deviceidhint();
+}
+inline void SyncActionValue_StickerAction::clear_deviceidhint() {
+  _impl_.deviceidhint_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint32_t SyncActionValue_StickerAction::_internal_deviceidhint() const {
+  return _impl_.deviceidhint_;
+}
+inline uint32_t SyncActionValue_StickerAction::deviceidhint() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.deviceIdHint)
+  return _internal_deviceidhint();
+}
+inline void SyncActionValue_StickerAction::_internal_set_deviceidhint(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.deviceidhint_ = value;
+}
+inline void SyncActionValue_StickerAction::set_deviceidhint(uint32_t value) {
+  _internal_set_deviceidhint(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.deviceIdHint)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_SubscriptionAction
+
+// optional bool isDeactivated = 1;
+inline bool SyncActionValue_SubscriptionAction::_internal_has_isdeactivated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SubscriptionAction::has_isdeactivated() const {
+  return _internal_has_isdeactivated();
+}
+inline void SyncActionValue_SubscriptionAction::clear_isdeactivated() {
+  _impl_.isdeactivated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool SyncActionValue_SubscriptionAction::_internal_isdeactivated() const {
+  return _impl_.isdeactivated_;
+}
+inline bool SyncActionValue_SubscriptionAction::isdeactivated() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isDeactivated)
+  return _internal_isdeactivated();
+}
+inline void SyncActionValue_SubscriptionAction::_internal_set_isdeactivated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.isdeactivated_ = value;
+}
+inline void SyncActionValue_SubscriptionAction::set_isdeactivated(bool value) {
+  _internal_set_isdeactivated(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isDeactivated)
+}
+
+// optional bool isAutoRenewing = 2;
+inline bool SyncActionValue_SubscriptionAction::_internal_has_isautorenewing() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SubscriptionAction::has_isautorenewing() const {
+  return _internal_has_isautorenewing();
+}
+inline void SyncActionValue_SubscriptionAction::clear_isautorenewing() {
+  _impl_.isautorenewing_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool SyncActionValue_SubscriptionAction::_internal_isautorenewing() const {
+  return _impl_.isautorenewing_;
+}
+inline bool SyncActionValue_SubscriptionAction::isautorenewing() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isAutoRenewing)
+  return _internal_isautorenewing();
+}
+inline void SyncActionValue_SubscriptionAction::_internal_set_isautorenewing(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.isautorenewing_ = value;
+}
+inline void SyncActionValue_SubscriptionAction::set_isautorenewing(bool value) {
+  _internal_set_isautorenewing(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isAutoRenewing)
+}
+
+// optional int64 expirationDate = 3;
+inline bool SyncActionValue_SubscriptionAction::_internal_has_expirationdate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SubscriptionAction::has_expirationdate() const {
+  return _internal_has_expirationdate();
+}
+inline void SyncActionValue_SubscriptionAction::clear_expirationdate() {
+  _impl_.expirationdate_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t SyncActionValue_SubscriptionAction::_internal_expirationdate() const {
+  return _impl_.expirationdate_;
+}
+inline int64_t SyncActionValue_SubscriptionAction::expirationdate() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.expirationDate)
+  return _internal_expirationdate();
+}
+inline void SyncActionValue_SubscriptionAction::_internal_set_expirationdate(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.expirationdate_ = value;
+}
+inline void SyncActionValue_SubscriptionAction::set_expirationdate(int64_t value) {
+  _internal_set_expirationdate(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.expirationDate)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_SyncActionMessageRange
+
+// optional int64 lastMessageTimestamp = 1;
+inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastmessagetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SyncActionMessageRange::has_lastmessagetimestamp() const {
+  return _internal_has_lastmessagetimestamp();
+}
+inline void SyncActionValue_SyncActionMessageRange::clear_lastmessagetimestamp() {
+  _impl_.lastmessagetimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastmessagetimestamp() const {
+  return _impl_.lastmessagetimestamp_;
+}
+inline int64_t SyncActionValue_SyncActionMessageRange::lastmessagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp)
+  return _internal_lastmessagetimestamp();
+}
+inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastmessagetimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.lastmessagetimestamp_ = value;
+}
+inline void SyncActionValue_SyncActionMessageRange::set_lastmessagetimestamp(int64_t value) {
+  _internal_set_lastmessagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp)
+}
+
+// optional int64 lastSystemMessageTimestamp = 2;
+inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastsystemmessagetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SyncActionMessageRange::has_lastsystemmessagetimestamp() const {
+  return _internal_has_lastsystemmessagetimestamp();
+}
+inline void SyncActionValue_SyncActionMessageRange::clear_lastsystemmessagetimestamp() {
+  _impl_.lastsystemmessagetimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastsystemmessagetimestamp() const {
+  return _impl_.lastsystemmessagetimestamp_;
+}
+inline int64_t SyncActionValue_SyncActionMessageRange::lastsystemmessagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp)
+  return _internal_lastsystemmessagetimestamp();
+}
+inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastsystemmessagetimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.lastsystemmessagetimestamp_ = value;
+}
+inline void SyncActionValue_SyncActionMessageRange::set_lastsystemmessagetimestamp(int64_t value) {
+  _internal_set_lastsystemmessagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp)
+}
+
+// repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
+inline int SyncActionValue_SyncActionMessageRange::_internal_messages_size() const {
+  return _impl_.messages_.size();
+}
+inline int SyncActionValue_SyncActionMessageRange::messages_size() const {
+  return _internal_messages_size();
+}
+inline void SyncActionValue_SyncActionMessageRange::clear_messages() {
+  _impl_.messages_.Clear();
+}
+inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::mutable_messages(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessageRange.messages)
+  return _impl_.messages_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >*
+SyncActionValue_SyncActionMessageRange::mutable_messages() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.SyncActionMessageRange.messages)
+  return &_impl_.messages_;
+}
+inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::_internal_messages(int index) const {
+  return _impl_.messages_.Get(index);
+}
+inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::messages(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.messages)
+  return _internal_messages(index);
+}
+inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::_internal_add_messages() {
+  return _impl_.messages_.Add();
+}
+inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::add_messages() {
+  ::proto::SyncActionValue_SyncActionMessage* _add = _internal_add_messages();
+  // @@protoc_insertion_point(field_add:proto.SyncActionValue.SyncActionMessageRange.messages)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >&
+SyncActionValue_SyncActionMessageRange::messages() const {
+  // @@protoc_insertion_point(field_list:proto.SyncActionValue.SyncActionMessageRange.messages)
+  return _impl_.messages_;
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_SyncActionMessage
+
+// optional .proto.MessageKey key = 1;
+inline bool SyncActionValue_SyncActionMessage::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue_SyncActionMessage::has_key() const {
+  return _internal_has_key();
+}
+inline void SyncActionValue_SyncActionMessage::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::key() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.key)
+  return _internal_key();
+}
+inline void SyncActionValue_SyncActionMessage::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.SyncActionMessage.key)
+}
+inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.SyncActionMessage.key)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessage.key)
+  return _msg;
+}
+inline void SyncActionValue_SyncActionMessage::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.SyncActionMessage.key)
+}
+
+// optional int64 timestamp = 2;
+inline bool SyncActionValue_SyncActionMessage::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncActionValue_SyncActionMessage::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void SyncActionValue_SyncActionMessage::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t SyncActionValue_SyncActionMessage::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t SyncActionValue_SyncActionMessage::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.timestamp)
+  return _internal_timestamp();
+}
+inline void SyncActionValue_SyncActionMessage::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.timestamp_ = value;
+}
+inline void SyncActionValue_SyncActionMessage::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessage.timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_TimeFormatAction
+
+// optional bool isTwentyFourHourFormatEnabled = 1;
+inline bool SyncActionValue_TimeFormatAction::_internal_has_istwentyfourhourformatenabled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_TimeFormatAction::has_istwentyfourhourformatenabled() const {
+  return _internal_has_istwentyfourhourformatenabled();
+}
+inline void SyncActionValue_TimeFormatAction::clear_istwentyfourhourformatenabled() {
+  _impl_.istwentyfourhourformatenabled_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_TimeFormatAction::_internal_istwentyfourhourformatenabled() const {
+  return _impl_.istwentyfourhourformatenabled_;
+}
+inline bool SyncActionValue_TimeFormatAction::istwentyfourhourformatenabled() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled)
+  return _internal_istwentyfourhourformatenabled();
+}
+inline void SyncActionValue_TimeFormatAction::_internal_set_istwentyfourhourformatenabled(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.istwentyfourhourformatenabled_ = value;
+}
+inline void SyncActionValue_TimeFormatAction::set_istwentyfourhourformatenabled(bool value) {
+  _internal_set_istwentyfourhourformatenabled(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_UnarchiveChatsSetting
+
+// optional bool unarchiveChats = 1;
+inline bool SyncActionValue_UnarchiveChatsSetting::_internal_has_unarchivechats() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_UnarchiveChatsSetting::has_unarchivechats() const {
+  return _internal_has_unarchivechats();
+}
+inline void SyncActionValue_UnarchiveChatsSetting::clear_unarchivechats() {
+  _impl_.unarchivechats_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_UnarchiveChatsSetting::_internal_unarchivechats() const {
+  return _impl_.unarchivechats_;
+}
+inline bool SyncActionValue_UnarchiveChatsSetting::unarchivechats() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats)
+  return _internal_unarchivechats();
+}
+inline void SyncActionValue_UnarchiveChatsSetting::_internal_set_unarchivechats(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.unarchivechats_ = value;
+}
+inline void SyncActionValue_UnarchiveChatsSetting::set_unarchivechats(bool value) {
+  _internal_set_unarchivechats(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue_UserStatusMuteAction
+
+// optional bool muted = 1;
+inline bool SyncActionValue_UserStatusMuteAction::_internal_has_muted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncActionValue_UserStatusMuteAction::has_muted() const {
+  return _internal_has_muted();
+}
+inline void SyncActionValue_UserStatusMuteAction::clear_muted() {
+  _impl_.muted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool SyncActionValue_UserStatusMuteAction::_internal_muted() const {
+  return _impl_.muted_;
+}
+inline bool SyncActionValue_UserStatusMuteAction::muted() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.UserStatusMuteAction.muted)
+  return _internal_muted();
+}
+inline void SyncActionValue_UserStatusMuteAction::_internal_set_muted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.muted_ = value;
+}
+inline void SyncActionValue_UserStatusMuteAction::set_muted(bool value) {
+  _internal_set_muted(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.UserStatusMuteAction.muted)
+}
+
+// -------------------------------------------------------------------
+
+// SyncActionValue
+
+// optional int64 timestamp = 1;
+inline bool SyncActionValue::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
+  return value;
+}
+inline bool SyncActionValue::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void SyncActionValue::clear_timestamp() {
+  _impl_.timestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x08000000u;
+}
+inline int64_t SyncActionValue::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline int64_t SyncActionValue::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.timestamp)
+  return _internal_timestamp();
+}
+inline void SyncActionValue::_internal_set_timestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x08000000u;
+  _impl_.timestamp_ = value;
+}
+inline void SyncActionValue::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.SyncActionValue.timestamp)
+}
+
+// optional .proto.SyncActionValue.StarAction starAction = 2;
+inline bool SyncActionValue::_internal_has_staraction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.staraction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_staraction() const {
+  return _internal_has_staraction();
+}
+inline void SyncActionValue::clear_staraction() {
+  if (_impl_.staraction_ != nullptr) _impl_.staraction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncActionValue_StarAction& SyncActionValue::_internal_staraction() const {
+  const ::proto::SyncActionValue_StarAction* p = _impl_.staraction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_StarAction&>(
+      ::proto::_SyncActionValue_StarAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_StarAction& SyncActionValue::staraction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.starAction)
+  return _internal_staraction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_staraction(
+    ::proto::SyncActionValue_StarAction* staraction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.staraction_);
+  }
+  _impl_.staraction_ = staraction;
+  if (staraction) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.starAction)
+}
+inline ::proto::SyncActionValue_StarAction* SyncActionValue::release_staraction() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_;
+  _impl_.staraction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_StarAction* SyncActionValue::unsafe_arena_release_staraction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.starAction)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_;
+  _impl_.staraction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_StarAction* SyncActionValue::_internal_mutable_staraction() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.staraction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_StarAction>(GetArenaForAllocation());
+    _impl_.staraction_ = p;
+  }
+  return _impl_.staraction_;
+}
+inline ::proto::SyncActionValue_StarAction* SyncActionValue::mutable_staraction() {
+  ::proto::SyncActionValue_StarAction* _msg = _internal_mutable_staraction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.starAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.staraction_;
+  }
+  if (staraction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(staraction);
+    if (message_arena != submessage_arena) {
+      staraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, staraction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.staraction_ = staraction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.starAction)
+}
+
+// optional .proto.SyncActionValue.ContactAction contactAction = 3;
+inline bool SyncActionValue::_internal_has_contactaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.contactaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_contactaction() const {
+  return _internal_has_contactaction();
+}
+inline void SyncActionValue::clear_contactaction() {
+  if (_impl_.contactaction_ != nullptr) _impl_.contactaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::_internal_contactaction() const {
+  const ::proto::SyncActionValue_ContactAction* p = _impl_.contactaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ContactAction&>(
+      ::proto::_SyncActionValue_ContactAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::contactaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.contactAction)
+  return _internal_contactaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_contactaction(
+    ::proto::SyncActionValue_ContactAction* contactaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactaction_);
+  }
+  _impl_.contactaction_ = contactaction;
+  if (contactaction) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.contactAction)
+}
+inline ::proto::SyncActionValue_ContactAction* SyncActionValue::release_contactaction() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_;
+  _impl_.contactaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_ContactAction* SyncActionValue::unsafe_arena_release_contactaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.contactAction)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_;
+  _impl_.contactaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_ContactAction* SyncActionValue::_internal_mutable_contactaction() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.contactaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(GetArenaForAllocation());
+    _impl_.contactaction_ = p;
+  }
+  return _impl_.contactaction_;
+}
+inline ::proto::SyncActionValue_ContactAction* SyncActionValue::mutable_contactaction() {
+  ::proto::SyncActionValue_ContactAction* _msg = _internal_mutable_contactaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.contactAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.contactaction_;
+  }
+  if (contactaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactaction);
+    if (message_arena != submessage_arena) {
+      contactaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, contactaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.contactaction_ = contactaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.contactAction)
+}
+
+// optional .proto.SyncActionValue.MuteAction muteAction = 4;
+inline bool SyncActionValue::_internal_has_muteaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.muteaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_muteaction() const {
+  return _internal_has_muteaction();
+}
+inline void SyncActionValue::clear_muteaction() {
+  if (_impl_.muteaction_ != nullptr) _impl_.muteaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::_internal_muteaction() const {
+  const ::proto::SyncActionValue_MuteAction* p = _impl_.muteaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_MuteAction&>(
+      ::proto::_SyncActionValue_MuteAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::muteaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.muteAction)
+  return _internal_muteaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_muteaction(
+    ::proto::SyncActionValue_MuteAction* muteaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.muteaction_);
+  }
+  _impl_.muteaction_ = muteaction;
+  if (muteaction) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.muteAction)
+}
+inline ::proto::SyncActionValue_MuteAction* SyncActionValue::release_muteaction() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_;
+  _impl_.muteaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_MuteAction* SyncActionValue::unsafe_arena_release_muteaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.muteAction)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_;
+  _impl_.muteaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_MuteAction* SyncActionValue::_internal_mutable_muteaction() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.muteaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(GetArenaForAllocation());
+    _impl_.muteaction_ = p;
+  }
+  return _impl_.muteaction_;
+}
+inline ::proto::SyncActionValue_MuteAction* SyncActionValue::mutable_muteaction() {
+  ::proto::SyncActionValue_MuteAction* _msg = _internal_mutable_muteaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.muteAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.muteaction_;
+  }
+  if (muteaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(muteaction);
+    if (message_arena != submessage_arena) {
+      muteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, muteaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.muteaction_ = muteaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.muteAction)
+}
+
+// optional .proto.SyncActionValue.PinAction pinAction = 5;
+inline bool SyncActionValue::_internal_has_pinaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pinaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_pinaction() const {
+  return _internal_has_pinaction();
+}
+inline void SyncActionValue::clear_pinaction() {
+  if (_impl_.pinaction_ != nullptr) _impl_.pinaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::SyncActionValue_PinAction& SyncActionValue::_internal_pinaction() const {
+  const ::proto::SyncActionValue_PinAction* p = _impl_.pinaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PinAction&>(
+      ::proto::_SyncActionValue_PinAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_PinAction& SyncActionValue::pinaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.pinAction)
+  return _internal_pinaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_pinaction(
+    ::proto::SyncActionValue_PinAction* pinaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pinaction_);
+  }
+  _impl_.pinaction_ = pinaction;
+  if (pinaction) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pinAction)
+}
+inline ::proto::SyncActionValue_PinAction* SyncActionValue::release_pinaction() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_;
+  _impl_.pinaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_PinAction* SyncActionValue::unsafe_arena_release_pinaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.pinAction)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_;
+  _impl_.pinaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_PinAction* SyncActionValue::_internal_mutable_pinaction() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.pinaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PinAction>(GetArenaForAllocation());
+    _impl_.pinaction_ = p;
+  }
+  return _impl_.pinaction_;
+}
+inline ::proto::SyncActionValue_PinAction* SyncActionValue::mutable_pinaction() {
+  ::proto::SyncActionValue_PinAction* _msg = _internal_mutable_pinaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pinAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pinaction_;
+  }
+  if (pinaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pinaction);
+    if (message_arena != submessage_arena) {
+      pinaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pinaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.pinaction_ = pinaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pinAction)
+}
+
+// optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
+inline bool SyncActionValue::_internal_has_securitynotificationsetting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.securitynotificationsetting_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_securitynotificationsetting() const {
+  return _internal_has_securitynotificationsetting();
+}
+inline void SyncActionValue::clear_securitynotificationsetting() {
+  if (_impl_.securitynotificationsetting_ != nullptr) _impl_.securitynotificationsetting_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::_internal_securitynotificationsetting() const {
+  const ::proto::SyncActionValue_SecurityNotificationSetting* p = _impl_.securitynotificationsetting_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SecurityNotificationSetting&>(
+      ::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_);
+}
+inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::securitynotificationsetting() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.securityNotificationSetting)
+  return _internal_securitynotificationsetting();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_securitynotificationsetting(
+    ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.securitynotificationsetting_);
+  }
+  _impl_.securitynotificationsetting_ = securitynotificationsetting;
+  if (securitynotificationsetting) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.securityNotificationSetting)
+}
+inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::release_securitynotificationsetting() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_;
+  _impl_.securitynotificationsetting_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::unsafe_arena_release_securitynotificationsetting() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.securityNotificationSetting)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_;
+  _impl_.securitynotificationsetting_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::_internal_mutable_securitynotificationsetting() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.securitynotificationsetting_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(GetArenaForAllocation());
+    _impl_.securitynotificationsetting_ = p;
+  }
+  return _impl_.securitynotificationsetting_;
+}
+inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::mutable_securitynotificationsetting() {
+  ::proto::SyncActionValue_SecurityNotificationSetting* _msg = _internal_mutable_securitynotificationsetting();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.securityNotificationSetting)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.securitynotificationsetting_;
+  }
+  if (securitynotificationsetting) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(securitynotificationsetting);
+    if (message_arena != submessage_arena) {
+      securitynotificationsetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, securitynotificationsetting, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.securitynotificationsetting_ = securitynotificationsetting;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.securityNotificationSetting)
+}
+
+// optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
+inline bool SyncActionValue::_internal_has_pushnamesetting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pushnamesetting_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_pushnamesetting() const {
+  return _internal_has_pushnamesetting();
+}
+inline void SyncActionValue::clear_pushnamesetting() {
+  if (_impl_.pushnamesetting_ != nullptr) _impl_.pushnamesetting_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::_internal_pushnamesetting() const {
+  const ::proto::SyncActionValue_PushNameSetting* p = _impl_.pushnamesetting_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PushNameSetting&>(
+      ::proto::_SyncActionValue_PushNameSetting_default_instance_);
+}
+inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::pushnamesetting() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.pushNameSetting)
+  return _internal_pushnamesetting();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_pushnamesetting(
+    ::proto::SyncActionValue_PushNameSetting* pushnamesetting) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pushnamesetting_);
+  }
+  _impl_.pushnamesetting_ = pushnamesetting;
+  if (pushnamesetting) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pushNameSetting)
+}
+inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::release_pushnamesetting() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_;
+  _impl_.pushnamesetting_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::unsafe_arena_release_pushnamesetting() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.pushNameSetting)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_;
+  _impl_.pushnamesetting_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::_internal_mutable_pushnamesetting() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.pushnamesetting_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(GetArenaForAllocation());
+    _impl_.pushnamesetting_ = p;
+  }
+  return _impl_.pushnamesetting_;
+}
+inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::mutable_pushnamesetting() {
+  ::proto::SyncActionValue_PushNameSetting* _msg = _internal_mutable_pushnamesetting();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pushNameSetting)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pushnamesetting_;
+  }
+  if (pushnamesetting) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pushnamesetting);
+    if (message_arena != submessage_arena) {
+      pushnamesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pushnamesetting, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.pushnamesetting_ = pushnamesetting;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pushNameSetting)
+}
+
+// optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
+inline bool SyncActionValue::_internal_has_quickreplyaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quickreplyaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_quickreplyaction() const {
+  return _internal_has_quickreplyaction();
+}
+inline void SyncActionValue::clear_quickreplyaction() {
+  if (_impl_.quickreplyaction_ != nullptr) _impl_.quickreplyaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::_internal_quickreplyaction() const {
+  const ::proto::SyncActionValue_QuickReplyAction* p = _impl_.quickreplyaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_QuickReplyAction&>(
+      ::proto::_SyncActionValue_QuickReplyAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::quickreplyaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.quickReplyAction)
+  return _internal_quickreplyaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_quickreplyaction(
+    ::proto::SyncActionValue_QuickReplyAction* quickreplyaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quickreplyaction_);
+  }
+  _impl_.quickreplyaction_ = quickreplyaction;
+  if (quickreplyaction) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.quickReplyAction)
+}
+inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::release_quickreplyaction() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_;
+  _impl_.quickreplyaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::unsafe_arena_release_quickreplyaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.quickReplyAction)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_;
+  _impl_.quickreplyaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::_internal_mutable_quickreplyaction() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.quickreplyaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(GetArenaForAllocation());
+    _impl_.quickreplyaction_ = p;
+  }
+  return _impl_.quickreplyaction_;
+}
+inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::mutable_quickreplyaction() {
+  ::proto::SyncActionValue_QuickReplyAction* _msg = _internal_mutable_quickreplyaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.quickReplyAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quickreplyaction_;
+  }
+  if (quickreplyaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplyaction);
+    if (message_arena != submessage_arena) {
+      quickreplyaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quickreplyaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.quickreplyaction_ = quickreplyaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.quickReplyAction)
+}
+
+// optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+inline bool SyncActionValue::_internal_has_recentemojiweightsaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.recentemojiweightsaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_recentemojiweightsaction() const {
+  return _internal_has_recentemojiweightsaction();
+}
+inline void SyncActionValue::clear_recentemojiweightsaction() {
+  if (_impl_.recentemojiweightsaction_ != nullptr) _impl_.recentemojiweightsaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::_internal_recentemojiweightsaction() const {
+  const ::proto::SyncActionValue_RecentEmojiWeightsAction* p = _impl_.recentemojiweightsaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_RecentEmojiWeightsAction&>(
+      ::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::recentemojiweightsaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.recentEmojiWeightsAction)
+  return _internal_recentemojiweightsaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_recentemojiweightsaction(
+    ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.recentemojiweightsaction_);
+  }
+  _impl_.recentemojiweightsaction_ = recentemojiweightsaction;
+  if (recentemojiweightsaction) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction)
+}
+inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::release_recentemojiweightsaction() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_;
+  _impl_.recentemojiweightsaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::unsafe_arena_release_recentemojiweightsaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.recentEmojiWeightsAction)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_;
+  _impl_.recentemojiweightsaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::_internal_mutable_recentemojiweightsaction() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.recentemojiweightsaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(GetArenaForAllocation());
+    _impl_.recentemojiweightsaction_ = p;
+  }
+  return _impl_.recentemojiweightsaction_;
+}
+inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::mutable_recentemojiweightsaction() {
+  ::proto::SyncActionValue_RecentEmojiWeightsAction* _msg = _internal_mutable_recentemojiweightsaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.recentEmojiWeightsAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.recentemojiweightsaction_;
+  }
+  if (recentemojiweightsaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(recentemojiweightsaction);
+    if (message_arena != submessage_arena) {
+      recentemojiweightsaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, recentemojiweightsaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.recentemojiweightsaction_ = recentemojiweightsaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction)
+}
+
+// optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
+inline bool SyncActionValue::_internal_has_labeleditaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.labeleditaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_labeleditaction() const {
+  return _internal_has_labeleditaction();
+}
+inline void SyncActionValue::clear_labeleditaction() {
+  if (_impl_.labeleditaction_ != nullptr) _impl_.labeleditaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::_internal_labeleditaction() const {
+  const ::proto::SyncActionValue_LabelEditAction* p = _impl_.labeleditaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LabelEditAction&>(
+      ::proto::_SyncActionValue_LabelEditAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::labeleditaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelEditAction)
+  return _internal_labeleditaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_labeleditaction(
+    ::proto::SyncActionValue_LabelEditAction* labeleditaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labeleditaction_);
+  }
+  _impl_.labeleditaction_ = labeleditaction;
+  if (labeleditaction) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelEditAction)
+}
+inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::release_labeleditaction() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_;
+  _impl_.labeleditaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::unsafe_arena_release_labeleditaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelEditAction)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_;
+  _impl_.labeleditaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::_internal_mutable_labeleditaction() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.labeleditaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(GetArenaForAllocation());
+    _impl_.labeleditaction_ = p;
+  }
+  return _impl_.labeleditaction_;
+}
+inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::mutable_labeleditaction() {
+  ::proto::SyncActionValue_LabelEditAction* _msg = _internal_mutable_labeleditaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelEditAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.labeleditaction_;
+  }
+  if (labeleditaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labeleditaction);
+    if (message_arena != submessage_arena) {
+      labeleditaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, labeleditaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.labeleditaction_ = labeleditaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelEditAction)
+}
+
+// optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
+inline bool SyncActionValue::_internal_has_labelassociationaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.labelassociationaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_labelassociationaction() const {
+  return _internal_has_labelassociationaction();
+}
+inline void SyncActionValue::clear_labelassociationaction() {
+  if (_impl_.labelassociationaction_ != nullptr) _impl_.labelassociationaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::_internal_labelassociationaction() const {
+  const ::proto::SyncActionValue_LabelAssociationAction* p = _impl_.labelassociationaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LabelAssociationAction&>(
+      ::proto::_SyncActionValue_LabelAssociationAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::labelassociationaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelAssociationAction)
+  return _internal_labelassociationaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_labelassociationaction(
+    ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labelassociationaction_);
+  }
+  _impl_.labelassociationaction_ = labelassociationaction;
+  if (labelassociationaction) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelAssociationAction)
+}
+inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::release_labelassociationaction() {
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_;
+  _impl_.labelassociationaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::unsafe_arena_release_labelassociationaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelAssociationAction)
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_;
+  _impl_.labelassociationaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::_internal_mutable_labelassociationaction() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  if (_impl_.labelassociationaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(GetArenaForAllocation());
+    _impl_.labelassociationaction_ = p;
+  }
+  return _impl_.labelassociationaction_;
+}
+inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::mutable_labelassociationaction() {
+  ::proto::SyncActionValue_LabelAssociationAction* _msg = _internal_mutable_labelassociationaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelAssociationAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.labelassociationaction_;
+  }
+  if (labelassociationaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labelassociationaction);
+    if (message_arena != submessage_arena) {
+      labelassociationaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, labelassociationaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.labelassociationaction_ = labelassociationaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelAssociationAction)
+}
+
+// optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
+inline bool SyncActionValue::_internal_has_localesetting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.localesetting_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_localesetting() const {
+  return _internal_has_localesetting();
+}
+inline void SyncActionValue::clear_localesetting() {
+  if (_impl_.localesetting_ != nullptr) _impl_.localesetting_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::_internal_localesetting() const {
+  const ::proto::SyncActionValue_LocaleSetting* p = _impl_.localesetting_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LocaleSetting&>(
+      ::proto::_SyncActionValue_LocaleSetting_default_instance_);
+}
+inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::localesetting() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.localeSetting)
+  return _internal_localesetting();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_localesetting(
+    ::proto::SyncActionValue_LocaleSetting* localesetting) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.localesetting_);
+  }
+  _impl_.localesetting_ = localesetting;
+  if (localesetting) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.localeSetting)
+}
+inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::release_localesetting() {
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_;
+  _impl_.localesetting_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::unsafe_arena_release_localesetting() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.localeSetting)
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_;
+  _impl_.localesetting_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::_internal_mutable_localesetting() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  if (_impl_.localesetting_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(GetArenaForAllocation());
+    _impl_.localesetting_ = p;
+  }
+  return _impl_.localesetting_;
+}
+inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::mutable_localesetting() {
+  ::proto::SyncActionValue_LocaleSetting* _msg = _internal_mutable_localesetting();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.localeSetting)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.localesetting_;
+  }
+  if (localesetting) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(localesetting);
+    if (message_arena != submessage_arena) {
+      localesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, localesetting, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.localesetting_ = localesetting;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.localeSetting)
+}
+
+// optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
+inline bool SyncActionValue::_internal_has_archivechataction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.archivechataction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_archivechataction() const {
+  return _internal_has_archivechataction();
+}
+inline void SyncActionValue::clear_archivechataction() {
+  if (_impl_.archivechataction_ != nullptr) _impl_.archivechataction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::_internal_archivechataction() const {
+  const ::proto::SyncActionValue_ArchiveChatAction* p = _impl_.archivechataction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ArchiveChatAction&>(
+      ::proto::_SyncActionValue_ArchiveChatAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::archivechataction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.archiveChatAction)
+  return _internal_archivechataction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_archivechataction(
+    ::proto::SyncActionValue_ArchiveChatAction* archivechataction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.archivechataction_);
+  }
+  _impl_.archivechataction_ = archivechataction;
+  if (archivechataction) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.archiveChatAction)
+}
+inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::release_archivechataction() {
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_;
+  _impl_.archivechataction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::unsafe_arena_release_archivechataction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.archiveChatAction)
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_;
+  _impl_.archivechataction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::_internal_mutable_archivechataction() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  if (_impl_.archivechataction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(GetArenaForAllocation());
+    _impl_.archivechataction_ = p;
+  }
+  return _impl_.archivechataction_;
+}
+inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::mutable_archivechataction() {
+  ::proto::SyncActionValue_ArchiveChatAction* _msg = _internal_mutable_archivechataction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.archiveChatAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.archivechataction_;
+  }
+  if (archivechataction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(archivechataction);
+    if (message_arena != submessage_arena) {
+      archivechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, archivechataction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.archivechataction_ = archivechataction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.archiveChatAction)
+}
+
+// optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
+inline bool SyncActionValue::_internal_has_deletemessageformeaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.deletemessageformeaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_deletemessageformeaction() const {
+  return _internal_has_deletemessageformeaction();
+}
+inline void SyncActionValue::clear_deletemessageformeaction() {
+  if (_impl_.deletemessageformeaction_ != nullptr) _impl_.deletemessageformeaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::_internal_deletemessageformeaction() const {
+  const ::proto::SyncActionValue_DeleteMessageForMeAction* p = _impl_.deletemessageformeaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_DeleteMessageForMeAction&>(
+      ::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::deletemessageformeaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteMessageForMeAction)
+  return _internal_deletemessageformeaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_deletemessageformeaction(
+    ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletemessageformeaction_);
+  }
+  _impl_.deletemessageformeaction_ = deletemessageformeaction;
+  if (deletemessageformeaction) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteMessageForMeAction)
+}
+inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::release_deletemessageformeaction() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_;
+  _impl_.deletemessageformeaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::unsafe_arena_release_deletemessageformeaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteMessageForMeAction)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_;
+  _impl_.deletemessageformeaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::_internal_mutable_deletemessageformeaction() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.deletemessageformeaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(GetArenaForAllocation());
+    _impl_.deletemessageformeaction_ = p;
+  }
+  return _impl_.deletemessageformeaction_;
+}
+inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::mutable_deletemessageformeaction() {
+  ::proto::SyncActionValue_DeleteMessageForMeAction* _msg = _internal_mutable_deletemessageformeaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteMessageForMeAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.deletemessageformeaction_;
+  }
+  if (deletemessageformeaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletemessageformeaction);
+    if (message_arena != submessage_arena) {
+      deletemessageformeaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, deletemessageformeaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.deletemessageformeaction_ = deletemessageformeaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteMessageForMeAction)
+}
+
+// optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
+inline bool SyncActionValue::_internal_has_keyexpiration() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keyexpiration_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_keyexpiration() const {
+  return _internal_has_keyexpiration();
+}
+inline void SyncActionValue::clear_keyexpiration() {
+  if (_impl_.keyexpiration_ != nullptr) _impl_.keyexpiration_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::_internal_keyexpiration() const {
+  const ::proto::SyncActionValue_KeyExpiration* p = _impl_.keyexpiration_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_KeyExpiration&>(
+      ::proto::_SyncActionValue_KeyExpiration_default_instance_);
+}
+inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::keyexpiration() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.keyExpiration)
+  return _internal_keyexpiration();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_keyexpiration(
+    ::proto::SyncActionValue_KeyExpiration* keyexpiration) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyexpiration_);
+  }
+  _impl_.keyexpiration_ = keyexpiration;
+  if (keyexpiration) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.keyExpiration)
+}
+inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::release_keyexpiration() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_;
+  _impl_.keyexpiration_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::unsafe_arena_release_keyexpiration() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.keyExpiration)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_;
+  _impl_.keyexpiration_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::_internal_mutable_keyexpiration() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.keyexpiration_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(GetArenaForAllocation());
+    _impl_.keyexpiration_ = p;
+  }
+  return _impl_.keyexpiration_;
+}
+inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::mutable_keyexpiration() {
+  ::proto::SyncActionValue_KeyExpiration* _msg = _internal_mutable_keyexpiration();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.keyExpiration)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keyexpiration_;
+  }
+  if (keyexpiration) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyexpiration);
+    if (message_arena != submessage_arena) {
+      keyexpiration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keyexpiration, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.keyexpiration_ = keyexpiration;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.keyExpiration)
+}
+
+// optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
+inline bool SyncActionValue::_internal_has_markchatasreadaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.markchatasreadaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_markchatasreadaction() const {
+  return _internal_has_markchatasreadaction();
+}
+inline void SyncActionValue::clear_markchatasreadaction() {
+  if (_impl_.markchatasreadaction_ != nullptr) _impl_.markchatasreadaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::_internal_markchatasreadaction() const {
+  const ::proto::SyncActionValue_MarkChatAsReadAction* p = _impl_.markchatasreadaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_MarkChatAsReadAction&>(
+      ::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::markchatasreadaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.markChatAsReadAction)
+  return _internal_markchatasreadaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_markchatasreadaction(
+    ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.markchatasreadaction_);
+  }
+  _impl_.markchatasreadaction_ = markchatasreadaction;
+  if (markchatasreadaction) {
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.markChatAsReadAction)
+}
+inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::release_markchatasreadaction() {
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_;
+  _impl_.markchatasreadaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::unsafe_arena_release_markchatasreadaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.markChatAsReadAction)
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_;
+  _impl_.markchatasreadaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::_internal_mutable_markchatasreadaction() {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  if (_impl_.markchatasreadaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(GetArenaForAllocation());
+    _impl_.markchatasreadaction_ = p;
+  }
+  return _impl_.markchatasreadaction_;
+}
+inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::mutable_markchatasreadaction() {
+  ::proto::SyncActionValue_MarkChatAsReadAction* _msg = _internal_mutable_markchatasreadaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.markChatAsReadAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.markchatasreadaction_;
+  }
+  if (markchatasreadaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(markchatasreadaction);
+    if (message_arena != submessage_arena) {
+      markchatasreadaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, markchatasreadaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  _impl_.markchatasreadaction_ = markchatasreadaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.markChatAsReadAction)
+}
+
+// optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
+inline bool SyncActionValue::_internal_has_clearchataction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.clearchataction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_clearchataction() const {
+  return _internal_has_clearchataction();
+}
+inline void SyncActionValue::clear_clearchataction() {
+  if (_impl_.clearchataction_ != nullptr) _impl_.clearchataction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::_internal_clearchataction() const {
+  const ::proto::SyncActionValue_ClearChatAction* p = _impl_.clearchataction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ClearChatAction&>(
+      ::proto::_SyncActionValue_ClearChatAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::clearchataction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.clearChatAction)
+  return _internal_clearchataction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_clearchataction(
+    ::proto::SyncActionValue_ClearChatAction* clearchataction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clearchataction_);
+  }
+  _impl_.clearchataction_ = clearchataction;
+  if (clearchataction) {
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.clearChatAction)
+}
+inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::release_clearchataction() {
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_;
+  _impl_.clearchataction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::unsafe_arena_release_clearchataction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.clearChatAction)
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_;
+  _impl_.clearchataction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::_internal_mutable_clearchataction() {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  if (_impl_.clearchataction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(GetArenaForAllocation());
+    _impl_.clearchataction_ = p;
+  }
+  return _impl_.clearchataction_;
+}
+inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::mutable_clearchataction() {
+  ::proto::SyncActionValue_ClearChatAction* _msg = _internal_mutable_clearchataction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.clearChatAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.clearchataction_;
+  }
+  if (clearchataction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clearchataction);
+    if (message_arena != submessage_arena) {
+      clearchataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, clearchataction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  _impl_.clearchataction_ = clearchataction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.clearChatAction)
+}
+
+// optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
+inline bool SyncActionValue::_internal_has_deletechataction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.deletechataction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_deletechataction() const {
+  return _internal_has_deletechataction();
+}
+inline void SyncActionValue::clear_deletechataction() {
+  if (_impl_.deletechataction_ != nullptr) _impl_.deletechataction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::_internal_deletechataction() const {
+  const ::proto::SyncActionValue_DeleteChatAction* p = _impl_.deletechataction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_DeleteChatAction&>(
+      ::proto::_SyncActionValue_DeleteChatAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::deletechataction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteChatAction)
+  return _internal_deletechataction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_deletechataction(
+    ::proto::SyncActionValue_DeleteChatAction* deletechataction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletechataction_);
+  }
+  _impl_.deletechataction_ = deletechataction;
+  if (deletechataction) {
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteChatAction)
+}
+inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::release_deletechataction() {
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_;
+  _impl_.deletechataction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::unsafe_arena_release_deletechataction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteChatAction)
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_;
+  _impl_.deletechataction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::_internal_mutable_deletechataction() {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  if (_impl_.deletechataction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(GetArenaForAllocation());
+    _impl_.deletechataction_ = p;
+  }
+  return _impl_.deletechataction_;
+}
+inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::mutable_deletechataction() {
+  ::proto::SyncActionValue_DeleteChatAction* _msg = _internal_mutable_deletechataction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteChatAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.deletechataction_;
+  }
+  if (deletechataction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletechataction);
+    if (message_arena != submessage_arena) {
+      deletechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, deletechataction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  _impl_.deletechataction_ = deletechataction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteChatAction)
+}
+
+// optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
+inline bool SyncActionValue::_internal_has_unarchivechatssetting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.unarchivechatssetting_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_unarchivechatssetting() const {
+  return _internal_has_unarchivechatssetting();
+}
+inline void SyncActionValue::clear_unarchivechatssetting() {
+  if (_impl_.unarchivechatssetting_ != nullptr) _impl_.unarchivechatssetting_->Clear();
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::_internal_unarchivechatssetting() const {
+  const ::proto::SyncActionValue_UnarchiveChatsSetting* p = _impl_.unarchivechatssetting_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_UnarchiveChatsSetting&>(
+      ::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_);
+}
+inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::unarchivechatssetting() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.unarchiveChatsSetting)
+  return _internal_unarchivechatssetting();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_unarchivechatssetting(
+    ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unarchivechatssetting_);
+  }
+  _impl_.unarchivechatssetting_ = unarchivechatssetting;
+  if (unarchivechatssetting) {
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.unarchiveChatsSetting)
+}
+inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::release_unarchivechatssetting() {
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_;
+  _impl_.unarchivechatssetting_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::unsafe_arena_release_unarchivechatssetting() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.unarchiveChatsSetting)
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_;
+  _impl_.unarchivechatssetting_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::_internal_mutable_unarchivechatssetting() {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  if (_impl_.unarchivechatssetting_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(GetArenaForAllocation());
+    _impl_.unarchivechatssetting_ = p;
+  }
+  return _impl_.unarchivechatssetting_;
+}
+inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::mutable_unarchivechatssetting() {
+  ::proto::SyncActionValue_UnarchiveChatsSetting* _msg = _internal_mutable_unarchivechatssetting();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.unarchiveChatsSetting)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.unarchivechatssetting_;
+  }
+  if (unarchivechatssetting) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unarchivechatssetting);
+    if (message_arena != submessage_arena) {
+      unarchivechatssetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, unarchivechatssetting, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  _impl_.unarchivechatssetting_ = unarchivechatssetting;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.unarchiveChatsSetting)
+}
+
+// optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
+inline bool SyncActionValue::_internal_has_primaryfeature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.primaryfeature_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_primaryfeature() const {
+  return _internal_has_primaryfeature();
+}
+inline void SyncActionValue::clear_primaryfeature() {
+  if (_impl_.primaryfeature_ != nullptr) _impl_.primaryfeature_->Clear();
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::_internal_primaryfeature() const {
+  const ::proto::SyncActionValue_PrimaryFeature* p = _impl_.primaryfeature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PrimaryFeature&>(
+      ::proto::_SyncActionValue_PrimaryFeature_default_instance_);
+}
+inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::primaryfeature() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryFeature)
+  return _internal_primaryfeature();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_primaryfeature(
+    ::proto::SyncActionValue_PrimaryFeature* primaryfeature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryfeature_);
+  }
+  _impl_.primaryfeature_ = primaryfeature;
+  if (primaryfeature) {
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryFeature)
+}
+inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::release_primaryfeature() {
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_;
+  _impl_.primaryfeature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::unsafe_arena_release_primaryfeature() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryFeature)
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_;
+  _impl_.primaryfeature_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::_internal_mutable_primaryfeature() {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  if (_impl_.primaryfeature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(GetArenaForAllocation());
+    _impl_.primaryfeature_ = p;
+  }
+  return _impl_.primaryfeature_;
+}
+inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::mutable_primaryfeature() {
+  ::proto::SyncActionValue_PrimaryFeature* _msg = _internal_mutable_primaryfeature();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryFeature)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.primaryfeature_;
+  }
+  if (primaryfeature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryfeature);
+    if (message_arena != submessage_arena) {
+      primaryfeature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, primaryfeature, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  _impl_.primaryfeature_ = primaryfeature;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryFeature)
+}
+
+// optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
+inline bool SyncActionValue::_internal_has_androidunsupportedactions() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.androidunsupportedactions_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_androidunsupportedactions() const {
+  return _internal_has_androidunsupportedactions();
+}
+inline void SyncActionValue::clear_androidunsupportedactions() {
+  if (_impl_.androidunsupportedactions_ != nullptr) _impl_.androidunsupportedactions_->Clear();
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::_internal_androidunsupportedactions() const {
+  const ::proto::SyncActionValue_AndroidUnsupportedActions* p = _impl_.androidunsupportedactions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_AndroidUnsupportedActions&>(
+      ::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_);
+}
+inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::androidunsupportedactions() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.androidUnsupportedActions)
+  return _internal_androidunsupportedactions();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_androidunsupportedactions(
+    ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.androidunsupportedactions_);
+  }
+  _impl_.androidunsupportedactions_ = androidunsupportedactions;
+  if (androidunsupportedactions) {
+    _impl_._has_bits_[0] |= 0x00080000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00080000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.androidUnsupportedActions)
+}
+inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::release_androidunsupportedactions() {
+  _impl_._has_bits_[0] &= ~0x00080000u;
+  ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_;
+  _impl_.androidunsupportedactions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::unsafe_arena_release_androidunsupportedactions() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.androidUnsupportedActions)
+  _impl_._has_bits_[0] &= ~0x00080000u;
+  ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_;
+  _impl_.androidunsupportedactions_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::_internal_mutable_androidunsupportedactions() {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  if (_impl_.androidunsupportedactions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(GetArenaForAllocation());
+    _impl_.androidunsupportedactions_ = p;
+  }
+  return _impl_.androidunsupportedactions_;
+}
+inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::mutable_androidunsupportedactions() {
+  ::proto::SyncActionValue_AndroidUnsupportedActions* _msg = _internal_mutable_androidunsupportedactions();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.androidUnsupportedActions)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.androidunsupportedactions_;
+  }
+  if (androidunsupportedactions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(androidunsupportedactions);
+    if (message_arena != submessage_arena) {
+      androidunsupportedactions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, androidunsupportedactions, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00080000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00080000u;
+  }
+  _impl_.androidunsupportedactions_ = androidunsupportedactions;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.androidUnsupportedActions)
+}
+
+// optional .proto.SyncActionValue.AgentAction agentAction = 27;
+inline bool SyncActionValue::_internal_has_agentaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.agentaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_agentaction() const {
+  return _internal_has_agentaction();
+}
+inline void SyncActionValue::clear_agentaction() {
+  if (_impl_.agentaction_ != nullptr) _impl_.agentaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::_internal_agentaction() const {
+  const ::proto::SyncActionValue_AgentAction* p = _impl_.agentaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_AgentAction&>(
+      ::proto::_SyncActionValue_AgentAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::agentaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.agentAction)
+  return _internal_agentaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_agentaction(
+    ::proto::SyncActionValue_AgentAction* agentaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agentaction_);
+  }
+  _impl_.agentaction_ = agentaction;
+  if (agentaction) {
+    _impl_._has_bits_[0] |= 0x00100000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00100000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.agentAction)
+}
+inline ::proto::SyncActionValue_AgentAction* SyncActionValue::release_agentaction() {
+  _impl_._has_bits_[0] &= ~0x00100000u;
+  ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_;
+  _impl_.agentaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_AgentAction* SyncActionValue::unsafe_arena_release_agentaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.agentAction)
+  _impl_._has_bits_[0] &= ~0x00100000u;
+  ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_;
+  _impl_.agentaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_AgentAction* SyncActionValue::_internal_mutable_agentaction() {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  if (_impl_.agentaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(GetArenaForAllocation());
+    _impl_.agentaction_ = p;
+  }
+  return _impl_.agentaction_;
+}
+inline ::proto::SyncActionValue_AgentAction* SyncActionValue::mutable_agentaction() {
+  ::proto::SyncActionValue_AgentAction* _msg = _internal_mutable_agentaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.agentAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.agentaction_;
+  }
+  if (agentaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agentaction);
+    if (message_arena != submessage_arena) {
+      agentaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, agentaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00100000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00100000u;
+  }
+  _impl_.agentaction_ = agentaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.agentAction)
+}
+
+// optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
+inline bool SyncActionValue::_internal_has_subscriptionaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.subscriptionaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_subscriptionaction() const {
+  return _internal_has_subscriptionaction();
+}
+inline void SyncActionValue::clear_subscriptionaction() {
+  if (_impl_.subscriptionaction_ != nullptr) _impl_.subscriptionaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::_internal_subscriptionaction() const {
+  const ::proto::SyncActionValue_SubscriptionAction* p = _impl_.subscriptionaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SubscriptionAction&>(
+      ::proto::_SyncActionValue_SubscriptionAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::subscriptionaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.subscriptionAction)
+  return _internal_subscriptionaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_subscriptionaction(
+    ::proto::SyncActionValue_SubscriptionAction* subscriptionaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subscriptionaction_);
+  }
+  _impl_.subscriptionaction_ = subscriptionaction;
+  if (subscriptionaction) {
+    _impl_._has_bits_[0] |= 0x00200000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00200000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.subscriptionAction)
+}
+inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::release_subscriptionaction() {
+  _impl_._has_bits_[0] &= ~0x00200000u;
+  ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_;
+  _impl_.subscriptionaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::unsafe_arena_release_subscriptionaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.subscriptionAction)
+  _impl_._has_bits_[0] &= ~0x00200000u;
+  ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_;
+  _impl_.subscriptionaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::_internal_mutable_subscriptionaction() {
+  _impl_._has_bits_[0] |= 0x00200000u;
+  if (_impl_.subscriptionaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(GetArenaForAllocation());
+    _impl_.subscriptionaction_ = p;
+  }
+  return _impl_.subscriptionaction_;
+}
+inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::mutable_subscriptionaction() {
+  ::proto::SyncActionValue_SubscriptionAction* _msg = _internal_mutable_subscriptionaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.subscriptionAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.subscriptionaction_;
+  }
+  if (subscriptionaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscriptionaction);
+    if (message_arena != submessage_arena) {
+      subscriptionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, subscriptionaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00200000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00200000u;
+  }
+  _impl_.subscriptionaction_ = subscriptionaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.subscriptionAction)
+}
+
+// optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
+inline bool SyncActionValue::_internal_has_userstatusmuteaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.userstatusmuteaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_userstatusmuteaction() const {
+  return _internal_has_userstatusmuteaction();
+}
+inline void SyncActionValue::clear_userstatusmuteaction() {
+  if (_impl_.userstatusmuteaction_ != nullptr) _impl_.userstatusmuteaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::_internal_userstatusmuteaction() const {
+  const ::proto::SyncActionValue_UserStatusMuteAction* p = _impl_.userstatusmuteaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_UserStatusMuteAction&>(
+      ::proto::_SyncActionValue_UserStatusMuteAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::userstatusmuteaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.userStatusMuteAction)
+  return _internal_userstatusmuteaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_userstatusmuteaction(
+    ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.userstatusmuteaction_);
+  }
+  _impl_.userstatusmuteaction_ = userstatusmuteaction;
+  if (userstatusmuteaction) {
+    _impl_._has_bits_[0] |= 0x00400000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00400000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.userStatusMuteAction)
+}
+inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::release_userstatusmuteaction() {
+  _impl_._has_bits_[0] &= ~0x00400000u;
+  ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_;
+  _impl_.userstatusmuteaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::unsafe_arena_release_userstatusmuteaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.userStatusMuteAction)
+  _impl_._has_bits_[0] &= ~0x00400000u;
+  ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_;
+  _impl_.userstatusmuteaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::_internal_mutable_userstatusmuteaction() {
+  _impl_._has_bits_[0] |= 0x00400000u;
+  if (_impl_.userstatusmuteaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(GetArenaForAllocation());
+    _impl_.userstatusmuteaction_ = p;
+  }
+  return _impl_.userstatusmuteaction_;
+}
+inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::mutable_userstatusmuteaction() {
+  ::proto::SyncActionValue_UserStatusMuteAction* _msg = _internal_mutable_userstatusmuteaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.userStatusMuteAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.userstatusmuteaction_;
+  }
+  if (userstatusmuteaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(userstatusmuteaction);
+    if (message_arena != submessage_arena) {
+      userstatusmuteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, userstatusmuteaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00400000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00400000u;
+  }
+  _impl_.userstatusmuteaction_ = userstatusmuteaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.userStatusMuteAction)
+}
+
+// optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
+inline bool SyncActionValue::_internal_has_timeformataction() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.timeformataction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_timeformataction() const {
+  return _internal_has_timeformataction();
+}
+inline void SyncActionValue::clear_timeformataction() {
+  if (_impl_.timeformataction_ != nullptr) _impl_.timeformataction_->Clear();
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::_internal_timeformataction() const {
+  const ::proto::SyncActionValue_TimeFormatAction* p = _impl_.timeformataction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_TimeFormatAction&>(
+      ::proto::_SyncActionValue_TimeFormatAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::timeformataction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.timeFormatAction)
+  return _internal_timeformataction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_timeformataction(
+    ::proto::SyncActionValue_TimeFormatAction* timeformataction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.timeformataction_);
+  }
+  _impl_.timeformataction_ = timeformataction;
+  if (timeformataction) {
+    _impl_._has_bits_[0] |= 0x00800000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00800000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.timeFormatAction)
+}
+inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::release_timeformataction() {
+  _impl_._has_bits_[0] &= ~0x00800000u;
+  ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_;
+  _impl_.timeformataction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::unsafe_arena_release_timeformataction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.timeFormatAction)
+  _impl_._has_bits_[0] &= ~0x00800000u;
+  ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_;
+  _impl_.timeformataction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::_internal_mutable_timeformataction() {
+  _impl_._has_bits_[0] |= 0x00800000u;
+  if (_impl_.timeformataction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(GetArenaForAllocation());
+    _impl_.timeformataction_ = p;
+  }
+  return _impl_.timeformataction_;
+}
+inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::mutable_timeformataction() {
+  ::proto::SyncActionValue_TimeFormatAction* _msg = _internal_mutable_timeformataction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.timeFormatAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.timeformataction_;
+  }
+  if (timeformataction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(timeformataction);
+    if (message_arena != submessage_arena) {
+      timeformataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timeformataction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00800000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00800000u;
+  }
+  _impl_.timeformataction_ = timeformataction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.timeFormatAction)
+}
+
+// optional .proto.SyncActionValue.NuxAction nuxAction = 31;
+inline bool SyncActionValue::_internal_has_nuxaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.nuxaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_nuxaction() const {
+  return _internal_has_nuxaction();
+}
+inline void SyncActionValue::clear_nuxaction() {
+  if (_impl_.nuxaction_ != nullptr) _impl_.nuxaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x01000000u;
+}
+inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::_internal_nuxaction() const {
+  const ::proto::SyncActionValue_NuxAction* p = _impl_.nuxaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_NuxAction&>(
+      ::proto::_SyncActionValue_NuxAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::nuxaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.nuxAction)
+  return _internal_nuxaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_nuxaction(
+    ::proto::SyncActionValue_NuxAction* nuxaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nuxaction_);
+  }
+  _impl_.nuxaction_ = nuxaction;
+  if (nuxaction) {
+    _impl_._has_bits_[0] |= 0x01000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x01000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.nuxAction)
+}
+inline ::proto::SyncActionValue_NuxAction* SyncActionValue::release_nuxaction() {
+  _impl_._has_bits_[0] &= ~0x01000000u;
+  ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_;
+  _impl_.nuxaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_NuxAction* SyncActionValue::unsafe_arena_release_nuxaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.nuxAction)
+  _impl_._has_bits_[0] &= ~0x01000000u;
+  ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_;
+  _impl_.nuxaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_NuxAction* SyncActionValue::_internal_mutable_nuxaction() {
+  _impl_._has_bits_[0] |= 0x01000000u;
+  if (_impl_.nuxaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(GetArenaForAllocation());
+    _impl_.nuxaction_ = p;
+  }
+  return _impl_.nuxaction_;
+}
+inline ::proto::SyncActionValue_NuxAction* SyncActionValue::mutable_nuxaction() {
+  ::proto::SyncActionValue_NuxAction* _msg = _internal_mutable_nuxaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.nuxAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.nuxaction_;
+  }
+  if (nuxaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nuxaction);
+    if (message_arena != submessage_arena) {
+      nuxaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, nuxaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x01000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x01000000u;
+  }
+  _impl_.nuxaction_ = nuxaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.nuxAction)
+}
+
+// optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
+inline bool SyncActionValue::_internal_has_primaryversionaction() const {
+  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.primaryversionaction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_primaryversionaction() const {
+  return _internal_has_primaryversionaction();
+}
+inline void SyncActionValue::clear_primaryversionaction() {
+  if (_impl_.primaryversionaction_ != nullptr) _impl_.primaryversionaction_->Clear();
+  _impl_._has_bits_[0] &= ~0x02000000u;
+}
+inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::_internal_primaryversionaction() const {
+  const ::proto::SyncActionValue_PrimaryVersionAction* p = _impl_.primaryversionaction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PrimaryVersionAction&>(
+      ::proto::_SyncActionValue_PrimaryVersionAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::primaryversionaction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryVersionAction)
+  return _internal_primaryversionaction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_primaryversionaction(
+    ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryversionaction_);
+  }
+  _impl_.primaryversionaction_ = primaryversionaction;
+  if (primaryversionaction) {
+    _impl_._has_bits_[0] |= 0x02000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x02000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryVersionAction)
+}
+inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::release_primaryversionaction() {
+  _impl_._has_bits_[0] &= ~0x02000000u;
+  ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_;
+  _impl_.primaryversionaction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::unsafe_arena_release_primaryversionaction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryVersionAction)
+  _impl_._has_bits_[0] &= ~0x02000000u;
+  ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_;
+  _impl_.primaryversionaction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::_internal_mutable_primaryversionaction() {
+  _impl_._has_bits_[0] |= 0x02000000u;
+  if (_impl_.primaryversionaction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(GetArenaForAllocation());
+    _impl_.primaryversionaction_ = p;
+  }
+  return _impl_.primaryversionaction_;
+}
+inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::mutable_primaryversionaction() {
+  ::proto::SyncActionValue_PrimaryVersionAction* _msg = _internal_mutable_primaryversionaction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryVersionAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.primaryversionaction_;
+  }
+  if (primaryversionaction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryversionaction);
+    if (message_arena != submessage_arena) {
+      primaryversionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, primaryversionaction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x02000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x02000000u;
+  }
+  _impl_.primaryversionaction_ = primaryversionaction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryVersionAction)
+}
+
+// optional .proto.SyncActionValue.StickerAction stickerAction = 33;
+inline bool SyncActionValue::_internal_has_stickeraction() const {
+  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.stickeraction_ != nullptr);
+  return value;
+}
+inline bool SyncActionValue::has_stickeraction() const {
+  return _internal_has_stickeraction();
+}
+inline void SyncActionValue::clear_stickeraction() {
+  if (_impl_.stickeraction_ != nullptr) _impl_.stickeraction_->Clear();
+  _impl_._has_bits_[0] &= ~0x04000000u;
+}
+inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::_internal_stickeraction() const {
+  const ::proto::SyncActionValue_StickerAction* p = _impl_.stickeraction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_StickerAction&>(
+      ::proto::_SyncActionValue_StickerAction_default_instance_);
+}
+inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::stickeraction() const {
+  // @@protoc_insertion_point(field_get:proto.SyncActionValue.stickerAction)
+  return _internal_stickeraction();
+}
+inline void SyncActionValue::unsafe_arena_set_allocated_stickeraction(
+    ::proto::SyncActionValue_StickerAction* stickeraction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickeraction_);
+  }
+  _impl_.stickeraction_ = stickeraction;
+  if (stickeraction) {
+    _impl_._has_bits_[0] |= 0x04000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x04000000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.stickerAction)
+}
+inline ::proto::SyncActionValue_StickerAction* SyncActionValue::release_stickeraction() {
+  _impl_._has_bits_[0] &= ~0x04000000u;
+  ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_;
+  _impl_.stickeraction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncActionValue_StickerAction* SyncActionValue::unsafe_arena_release_stickeraction() {
+  // @@protoc_insertion_point(field_release:proto.SyncActionValue.stickerAction)
+  _impl_._has_bits_[0] &= ~0x04000000u;
+  ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_;
+  _impl_.stickeraction_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncActionValue_StickerAction* SyncActionValue::_internal_mutable_stickeraction() {
+  _impl_._has_bits_[0] |= 0x04000000u;
+  if (_impl_.stickeraction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(GetArenaForAllocation());
+    _impl_.stickeraction_ = p;
+  }
+  return _impl_.stickeraction_;
+}
+inline ::proto::SyncActionValue_StickerAction* SyncActionValue::mutable_stickeraction() {
+  ::proto::SyncActionValue_StickerAction* _msg = _internal_mutable_stickeraction();
+  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.stickerAction)
+  return _msg;
+}
+inline void SyncActionValue::set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.stickeraction_;
+  }
+  if (stickeraction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickeraction);
+    if (message_arena != submessage_arena) {
+      stickeraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, stickeraction, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x04000000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x04000000u;
+  }
+  _impl_.stickeraction_ = stickeraction;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.stickerAction)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdIndex
+
+// optional bytes blob = 1;
+inline bool SyncdIndex::_internal_has_blob() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncdIndex::has_blob() const {
+  return _internal_has_blob();
+}
+inline void SyncdIndex::clear_blob() {
+  _impl_.blob_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncdIndex::blob() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdIndex.blob)
+  return _internal_blob();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncdIndex::set_blob(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.blob_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncdIndex.blob)
+}
+inline std::string* SyncdIndex::mutable_blob() {
+  std::string* _s = _internal_mutable_blob();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdIndex.blob)
+  return _s;
+}
+inline const std::string& SyncdIndex::_internal_blob() const {
+  return _impl_.blob_.Get();
+}
+inline void SyncdIndex::_internal_set_blob(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.blob_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncdIndex::_internal_mutable_blob() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.blob_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncdIndex::release_blob() {
+  // @@protoc_insertion_point(field_release:proto.SyncdIndex.blob)
+  if (!_internal_has_blob()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.blob_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blob_.IsDefault()) {
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncdIndex::set_allocated_blob(std::string* blob) {
+  if (blob != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.blob_.SetAllocated(blob, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blob_.IsDefault()) {
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdIndex.blob)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdMutation
+
+// optional .proto.SyncdMutation.SyncdOperation operation = 1;
+inline bool SyncdMutation::_internal_has_operation() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncdMutation::has_operation() const {
+  return _internal_has_operation();
+}
+inline void SyncdMutation::clear_operation() {
+  _impl_.operation_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::_internal_operation() const {
+  return static_cast< ::proto::SyncdMutation_SyncdOperation >(_impl_.operation_);
+}
+inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::operation() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdMutation.operation)
+  return _internal_operation();
+}
+inline void SyncdMutation::_internal_set_operation(::proto::SyncdMutation_SyncdOperation value) {
+  assert(::proto::SyncdMutation_SyncdOperation_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.operation_ = value;
+}
+inline void SyncdMutation::set_operation(::proto::SyncdMutation_SyncdOperation value) {
+  _internal_set_operation(value);
+  // @@protoc_insertion_point(field_set:proto.SyncdMutation.operation)
+}
+
+// optional .proto.SyncdRecord record = 2;
+inline bool SyncdMutation::_internal_has_record() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.record_ != nullptr);
+  return value;
+}
+inline bool SyncdMutation::has_record() const {
+  return _internal_has_record();
+}
+inline void SyncdMutation::clear_record() {
+  if (_impl_.record_ != nullptr) _impl_.record_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncdRecord& SyncdMutation::_internal_record() const {
+  const ::proto::SyncdRecord* p = _impl_.record_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdRecord&>(
+      ::proto::_SyncdRecord_default_instance_);
+}
+inline const ::proto::SyncdRecord& SyncdMutation::record() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdMutation.record)
+  return _internal_record();
+}
+inline void SyncdMutation::unsafe_arena_set_allocated_record(
+    ::proto::SyncdRecord* record) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.record_);
+  }
+  _impl_.record_ = record;
+  if (record) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdMutation.record)
+}
+inline ::proto::SyncdRecord* SyncdMutation::release_record() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncdRecord* temp = _impl_.record_;
+  _impl_.record_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncdRecord* SyncdMutation::unsafe_arena_release_record() {
+  // @@protoc_insertion_point(field_release:proto.SyncdMutation.record)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncdRecord* temp = _impl_.record_;
+  _impl_.record_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncdRecord* SyncdMutation::_internal_mutable_record() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.record_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncdRecord>(GetArenaForAllocation());
+    _impl_.record_ = p;
+  }
+  return _impl_.record_;
+}
+inline ::proto::SyncdRecord* SyncdMutation::mutable_record() {
+  ::proto::SyncdRecord* _msg = _internal_mutable_record();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdMutation.record)
+  return _msg;
+}
+inline void SyncdMutation::set_allocated_record(::proto::SyncdRecord* record) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.record_;
+  }
+  if (record) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(record);
+    if (message_arena != submessage_arena) {
+      record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, record, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.record_ = record;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdMutation.record)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdMutations
+
+// repeated .proto.SyncdMutation mutations = 1;
+inline int SyncdMutations::_internal_mutations_size() const {
+  return _impl_.mutations_.size();
+}
+inline int SyncdMutations::mutations_size() const {
+  return _internal_mutations_size();
+}
+inline void SyncdMutations::clear_mutations() {
+  _impl_.mutations_.Clear();
+}
+inline ::proto::SyncdMutation* SyncdMutations::mutable_mutations(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncdMutations.mutations)
+  return _impl_.mutations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
+SyncdMutations::mutable_mutations() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncdMutations.mutations)
+  return &_impl_.mutations_;
+}
+inline const ::proto::SyncdMutation& SyncdMutations::_internal_mutations(int index) const {
+  return _impl_.mutations_.Get(index);
+}
+inline const ::proto::SyncdMutation& SyncdMutations::mutations(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncdMutations.mutations)
+  return _internal_mutations(index);
+}
+inline ::proto::SyncdMutation* SyncdMutations::_internal_add_mutations() {
+  return _impl_.mutations_.Add();
+}
+inline ::proto::SyncdMutation* SyncdMutations::add_mutations() {
+  ::proto::SyncdMutation* _add = _internal_add_mutations();
+  // @@protoc_insertion_point(field_add:proto.SyncdMutations.mutations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
+SyncdMutations::mutations() const {
+  // @@protoc_insertion_point(field_list:proto.SyncdMutations.mutations)
+  return _impl_.mutations_;
+}
+
+// -------------------------------------------------------------------
+
+// SyncdPatch
+
+// optional .proto.SyncdVersion version = 1;
+inline bool SyncdPatch::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
+  return value;
+}
+inline bool SyncdPatch::has_version() const {
+  return _internal_has_version();
+}
+inline void SyncdPatch::clear_version() {
+  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::SyncdVersion& SyncdPatch::_internal_version() const {
+  const ::proto::SyncdVersion* p = _impl_.version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdVersion&>(
+      ::proto::_SyncdVersion_default_instance_);
+}
+inline const ::proto::SyncdVersion& SyncdPatch::version() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.version)
+  return _internal_version();
+}
+inline void SyncdPatch::unsafe_arena_set_allocated_version(
+    ::proto::SyncdVersion* version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
+  }
+  _impl_.version_ = version;
+  if (version) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.version)
+}
+inline ::proto::SyncdVersion* SyncdPatch::release_version() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncdVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncdVersion* SyncdPatch::unsafe_arena_release_version() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.version)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::SyncdVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncdVersion* SyncdPatch::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation());
+    _impl_.version_ = p;
+  }
+  return _impl_.version_;
+}
+inline ::proto::SyncdVersion* SyncdPatch::mutable_version() {
+  ::proto::SyncdVersion* _msg = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.version)
+  return _msg;
+}
+inline void SyncdPatch::set_allocated_version(::proto::SyncdVersion* version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.version_;
+  }
+  if (version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
+    if (message_arena != submessage_arena) {
+      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, version, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.version_ = version;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.version)
+}
+
+// repeated .proto.SyncdMutation mutations = 2;
+inline int SyncdPatch::_internal_mutations_size() const {
+  return _impl_.mutations_.size();
+}
+inline int SyncdPatch::mutations_size() const {
+  return _internal_mutations_size();
+}
+inline void SyncdPatch::clear_mutations() {
+  _impl_.mutations_.Clear();
+}
+inline ::proto::SyncdMutation* SyncdPatch::mutable_mutations(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.mutations)
+  return _impl_.mutations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
+SyncdPatch::mutable_mutations() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncdPatch.mutations)
+  return &_impl_.mutations_;
+}
+inline const ::proto::SyncdMutation& SyncdPatch::_internal_mutations(int index) const {
+  return _impl_.mutations_.Get(index);
+}
+inline const ::proto::SyncdMutation& SyncdPatch::mutations(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.mutations)
+  return _internal_mutations(index);
+}
+inline ::proto::SyncdMutation* SyncdPatch::_internal_add_mutations() {
+  return _impl_.mutations_.Add();
+}
+inline ::proto::SyncdMutation* SyncdPatch::add_mutations() {
+  ::proto::SyncdMutation* _add = _internal_add_mutations();
+  // @@protoc_insertion_point(field_add:proto.SyncdPatch.mutations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
+SyncdPatch::mutations() const {
+  // @@protoc_insertion_point(field_list:proto.SyncdPatch.mutations)
+  return _impl_.mutations_;
+}
+
+// optional .proto.ExternalBlobReference externalMutations = 3;
+inline bool SyncdPatch::_internal_has_externalmutations() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.externalmutations_ != nullptr);
+  return value;
+}
+inline bool SyncdPatch::has_externalmutations() const {
+  return _internal_has_externalmutations();
+}
+inline void SyncdPatch::clear_externalmutations() {
+  if (_impl_.externalmutations_ != nullptr) _impl_.externalmutations_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::proto::ExternalBlobReference& SyncdPatch::_internal_externalmutations() const {
+  const ::proto::ExternalBlobReference* p = _impl_.externalmutations_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ExternalBlobReference&>(
+      ::proto::_ExternalBlobReference_default_instance_);
+}
+inline const ::proto::ExternalBlobReference& SyncdPatch::externalmutations() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.externalMutations)
+  return _internal_externalmutations();
+}
+inline void SyncdPatch::unsafe_arena_set_allocated_externalmutations(
+    ::proto::ExternalBlobReference* externalmutations) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externalmutations_);
+  }
+  _impl_.externalmutations_ = externalmutations;
+  if (externalmutations) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.externalMutations)
+}
+inline ::proto::ExternalBlobReference* SyncdPatch::release_externalmutations() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ExternalBlobReference* temp = _impl_.externalmutations_;
+  _impl_.externalmutations_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ExternalBlobReference* SyncdPatch::unsafe_arena_release_externalmutations() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.externalMutations)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::proto::ExternalBlobReference* temp = _impl_.externalmutations_;
+  _impl_.externalmutations_ = nullptr;
+  return temp;
+}
+inline ::proto::ExternalBlobReference* SyncdPatch::_internal_mutable_externalmutations() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.externalmutations_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ExternalBlobReference>(GetArenaForAllocation());
+    _impl_.externalmutations_ = p;
+  }
+  return _impl_.externalmutations_;
+}
+inline ::proto::ExternalBlobReference* SyncdPatch::mutable_externalmutations() {
+  ::proto::ExternalBlobReference* _msg = _internal_mutable_externalmutations();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.externalMutations)
+  return _msg;
+}
+inline void SyncdPatch::set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.externalmutations_;
+  }
+  if (externalmutations) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externalmutations);
+    if (message_arena != submessage_arena) {
+      externalmutations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, externalmutations, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.externalmutations_ = externalmutations;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.externalMutations)
+}
+
+// optional bytes snapshotMac = 4;
+inline bool SyncdPatch::_internal_has_snapshotmac() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncdPatch::has_snapshotmac() const {
+  return _internal_has_snapshotmac();
+}
+inline void SyncdPatch::clear_snapshotmac() {
+  _impl_.snapshotmac_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncdPatch::snapshotmac() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.snapshotMac)
+  return _internal_snapshotmac();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncdPatch::set_snapshotmac(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.snapshotmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncdPatch.snapshotMac)
+}
+inline std::string* SyncdPatch::mutable_snapshotmac() {
+  std::string* _s = _internal_mutable_snapshotmac();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.snapshotMac)
+  return _s;
+}
+inline const std::string& SyncdPatch::_internal_snapshotmac() const {
+  return _impl_.snapshotmac_.Get();
+}
+inline void SyncdPatch::_internal_set_snapshotmac(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.snapshotmac_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncdPatch::_internal_mutable_snapshotmac() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.snapshotmac_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncdPatch::release_snapshotmac() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.snapshotMac)
+  if (!_internal_has_snapshotmac()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.snapshotmac_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.snapshotmac_.IsDefault()) {
+    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncdPatch::set_allocated_snapshotmac(std::string* snapshotmac) {
+  if (snapshotmac != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.snapshotmac_.SetAllocated(snapshotmac, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.snapshotmac_.IsDefault()) {
+    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.snapshotMac)
+}
+
+// optional bytes patchMac = 5;
+inline bool SyncdPatch::_internal_has_patchmac() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SyncdPatch::has_patchmac() const {
+  return _internal_has_patchmac();
+}
+inline void SyncdPatch::clear_patchmac() {
+  _impl_.patchmac_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SyncdPatch::patchmac() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.patchMac)
+  return _internal_patchmac();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncdPatch::set_patchmac(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.patchmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncdPatch.patchMac)
+}
+inline std::string* SyncdPatch::mutable_patchmac() {
+  std::string* _s = _internal_mutable_patchmac();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.patchMac)
+  return _s;
+}
+inline const std::string& SyncdPatch::_internal_patchmac() const {
+  return _impl_.patchmac_.Get();
+}
+inline void SyncdPatch::_internal_set_patchmac(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.patchmac_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncdPatch::_internal_mutable_patchmac() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.patchmac_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncdPatch::release_patchmac() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.patchMac)
+  if (!_internal_has_patchmac()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.patchmac_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.patchmac_.IsDefault()) {
+    _impl_.patchmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncdPatch::set_allocated_patchmac(std::string* patchmac) {
+  if (patchmac != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.patchmac_.SetAllocated(patchmac, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.patchmac_.IsDefault()) {
+    _impl_.patchmac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.patchMac)
+}
+
+// optional .proto.KeyId keyId = 6;
+inline bool SyncdPatch::_internal_has_keyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
+  return value;
+}
+inline bool SyncdPatch::has_keyid() const {
+  return _internal_has_keyid();
+}
+inline void SyncdPatch::clear_keyid() {
+  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::proto::KeyId& SyncdPatch::_internal_keyid() const {
+  const ::proto::KeyId* p = _impl_.keyid_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
+      ::proto::_KeyId_default_instance_);
+}
+inline const ::proto::KeyId& SyncdPatch::keyid() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.keyId)
+  return _internal_keyid();
+}
+inline void SyncdPatch::unsafe_arena_set_allocated_keyid(
+    ::proto::KeyId* keyid) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
+  }
+  _impl_.keyid_ = keyid;
+  if (keyid) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.keyId)
+}
+inline ::proto::KeyId* SyncdPatch::release_keyid() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::KeyId* SyncdPatch::unsafe_arena_release_keyid() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.keyId)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+  return temp;
+}
+inline ::proto::KeyId* SyncdPatch::_internal_mutable_keyid() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.keyid_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
+    _impl_.keyid_ = p;
+  }
+  return _impl_.keyid_;
+}
+inline ::proto::KeyId* SyncdPatch::mutable_keyid() {
+  ::proto::KeyId* _msg = _internal_mutable_keyid();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.keyId)
+  return _msg;
+}
+inline void SyncdPatch::set_allocated_keyid(::proto::KeyId* keyid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keyid_;
+  }
+  if (keyid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
+    if (message_arena != submessage_arena) {
+      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keyid, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.keyid_ = keyid;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.keyId)
+}
+
+// optional .proto.ExitCode exitCode = 7;
+inline bool SyncdPatch::_internal_has_exitcode() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.exitcode_ != nullptr);
+  return value;
+}
+inline bool SyncdPatch::has_exitcode() const {
+  return _internal_has_exitcode();
+}
+inline void SyncdPatch::clear_exitcode() {
+  if (_impl_.exitcode_ != nullptr) _impl_.exitcode_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::proto::ExitCode& SyncdPatch::_internal_exitcode() const {
+  const ::proto::ExitCode* p = _impl_.exitcode_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::ExitCode&>(
+      ::proto::_ExitCode_default_instance_);
+}
+inline const ::proto::ExitCode& SyncdPatch::exitcode() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.exitCode)
+  return _internal_exitcode();
+}
+inline void SyncdPatch::unsafe_arena_set_allocated_exitcode(
+    ::proto::ExitCode* exitcode) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exitcode_);
+  }
+  _impl_.exitcode_ = exitcode;
+  if (exitcode) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.exitCode)
+}
+inline ::proto::ExitCode* SyncdPatch::release_exitcode() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ExitCode* temp = _impl_.exitcode_;
+  _impl_.exitcode_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::ExitCode* SyncdPatch::unsafe_arena_release_exitcode() {
+  // @@protoc_insertion_point(field_release:proto.SyncdPatch.exitCode)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::proto::ExitCode* temp = _impl_.exitcode_;
+  _impl_.exitcode_ = nullptr;
+  return temp;
+}
+inline ::proto::ExitCode* SyncdPatch::_internal_mutable_exitcode() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.exitcode_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::ExitCode>(GetArenaForAllocation());
+    _impl_.exitcode_ = p;
+  }
+  return _impl_.exitcode_;
+}
+inline ::proto::ExitCode* SyncdPatch::mutable_exitcode() {
+  ::proto::ExitCode* _msg = _internal_mutable_exitcode();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.exitCode)
+  return _msg;
+}
+inline void SyncdPatch::set_allocated_exitcode(::proto::ExitCode* exitcode) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.exitcode_;
+  }
+  if (exitcode) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exitcode);
+    if (message_arena != submessage_arena) {
+      exitcode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, exitcode, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.exitcode_ = exitcode;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.exitCode)
+}
+
+// optional uint32 deviceIndex = 8;
+inline bool SyncdPatch::_internal_has_deviceindex() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SyncdPatch::has_deviceindex() const {
+  return _internal_has_deviceindex();
+}
+inline void SyncdPatch::clear_deviceindex() {
+  _impl_.deviceindex_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline uint32_t SyncdPatch::_internal_deviceindex() const {
+  return _impl_.deviceindex_;
+}
+inline uint32_t SyncdPatch::deviceindex() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdPatch.deviceIndex)
+  return _internal_deviceindex();
+}
+inline void SyncdPatch::_internal_set_deviceindex(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.deviceindex_ = value;
+}
+inline void SyncdPatch::set_deviceindex(uint32_t value) {
+  _internal_set_deviceindex(value);
+  // @@protoc_insertion_point(field_set:proto.SyncdPatch.deviceIndex)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdRecord
+
+// optional .proto.SyncdIndex index = 1;
+inline bool SyncdRecord::_internal_has_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.index_ != nullptr);
+  return value;
+}
+inline bool SyncdRecord::has_index() const {
+  return _internal_has_index();
+}
+inline void SyncdRecord::clear_index() {
+  if (_impl_.index_ != nullptr) _impl_.index_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::SyncdIndex& SyncdRecord::_internal_index() const {
+  const ::proto::SyncdIndex* p = _impl_.index_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdIndex&>(
+      ::proto::_SyncdIndex_default_instance_);
+}
+inline const ::proto::SyncdIndex& SyncdRecord::index() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdRecord.index)
+  return _internal_index();
+}
+inline void SyncdRecord::unsafe_arena_set_allocated_index(
+    ::proto::SyncdIndex* index) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.index_);
+  }
+  _impl_.index_ = index;
+  if (index) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.index)
+}
+inline ::proto::SyncdIndex* SyncdRecord::release_index() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncdIndex* temp = _impl_.index_;
+  _impl_.index_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncdIndex* SyncdRecord::unsafe_arena_release_index() {
+  // @@protoc_insertion_point(field_release:proto.SyncdRecord.index)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::SyncdIndex* temp = _impl_.index_;
+  _impl_.index_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncdIndex* SyncdRecord::_internal_mutable_index() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.index_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncdIndex>(GetArenaForAllocation());
+    _impl_.index_ = p;
+  }
+  return _impl_.index_;
+}
+inline ::proto::SyncdIndex* SyncdRecord::mutable_index() {
+  ::proto::SyncdIndex* _msg = _internal_mutable_index();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.index)
+  return _msg;
+}
+inline void SyncdRecord::set_allocated_index(::proto::SyncdIndex* index) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.index_;
+  }
+  if (index) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index);
+    if (message_arena != submessage_arena) {
+      index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, index, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.index_ = index;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.index)
+}
+
+// optional .proto.SyncdValue value = 2;
+inline bool SyncdRecord::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
+  return value;
+}
+inline bool SyncdRecord::has_value() const {
+  return _internal_has_value();
+}
+inline void SyncdRecord::clear_value() {
+  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::SyncdValue& SyncdRecord::_internal_value() const {
+  const ::proto::SyncdValue* p = _impl_.value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdValue&>(
+      ::proto::_SyncdValue_default_instance_);
+}
+inline const ::proto::SyncdValue& SyncdRecord::value() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdRecord.value)
+  return _internal_value();
+}
+inline void SyncdRecord::unsafe_arena_set_allocated_value(
+    ::proto::SyncdValue* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  _impl_.value_ = value;
+  if (value) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.value)
+}
+inline ::proto::SyncdValue* SyncdRecord::release_value() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncdValue* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncdValue* SyncdRecord::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:proto.SyncdRecord.value)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncdValue* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncdValue* SyncdRecord::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncdValue>(GetArenaForAllocation());
+    _impl_.value_ = p;
+  }
+  return _impl_.value_;
+}
+inline ::proto::SyncdValue* SyncdRecord::mutable_value() {
+  ::proto::SyncdValue* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.value)
+  return _msg;
+}
+inline void SyncdRecord::set_allocated_value(::proto::SyncdValue* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.value)
+}
+
+// optional .proto.KeyId keyId = 3;
+inline bool SyncdRecord::_internal_has_keyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
+  return value;
+}
+inline bool SyncdRecord::has_keyid() const {
+  return _internal_has_keyid();
+}
+inline void SyncdRecord::clear_keyid() {
+  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::KeyId& SyncdRecord::_internal_keyid() const {
+  const ::proto::KeyId* p = _impl_.keyid_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
+      ::proto::_KeyId_default_instance_);
+}
+inline const ::proto::KeyId& SyncdRecord::keyid() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdRecord.keyId)
+  return _internal_keyid();
+}
+inline void SyncdRecord::unsafe_arena_set_allocated_keyid(
+    ::proto::KeyId* keyid) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
+  }
+  _impl_.keyid_ = keyid;
+  if (keyid) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.keyId)
+}
+inline ::proto::KeyId* SyncdRecord::release_keyid() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::KeyId* SyncdRecord::unsafe_arena_release_keyid() {
+  // @@protoc_insertion_point(field_release:proto.SyncdRecord.keyId)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+  return temp;
+}
+inline ::proto::KeyId* SyncdRecord::_internal_mutable_keyid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.keyid_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
+    _impl_.keyid_ = p;
+  }
+  return _impl_.keyid_;
+}
+inline ::proto::KeyId* SyncdRecord::mutable_keyid() {
+  ::proto::KeyId* _msg = _internal_mutable_keyid();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.keyId)
+  return _msg;
+}
+inline void SyncdRecord::set_allocated_keyid(::proto::KeyId* keyid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keyid_;
+  }
+  if (keyid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
+    if (message_arena != submessage_arena) {
+      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keyid, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.keyid_ = keyid;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.keyId)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdSnapshot
+
+// optional .proto.SyncdVersion version = 1;
+inline bool SyncdSnapshot::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
+  return value;
+}
+inline bool SyncdSnapshot::has_version() const {
+  return _internal_has_version();
+}
+inline void SyncdSnapshot::clear_version() {
+  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::SyncdVersion& SyncdSnapshot::_internal_version() const {
+  const ::proto::SyncdVersion* p = _impl_.version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdVersion&>(
+      ::proto::_SyncdVersion_default_instance_);
+}
+inline const ::proto::SyncdVersion& SyncdSnapshot::version() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.version)
+  return _internal_version();
+}
+inline void SyncdSnapshot::unsafe_arena_set_allocated_version(
+    ::proto::SyncdVersion* version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
+  }
+  _impl_.version_ = version;
+  if (version) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.version)
+}
+inline ::proto::SyncdVersion* SyncdSnapshot::release_version() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncdVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::SyncdVersion* SyncdSnapshot::unsafe_arena_release_version() {
+  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.version)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::SyncdVersion* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+  return temp;
+}
+inline ::proto::SyncdVersion* SyncdSnapshot::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation());
+    _impl_.version_ = p;
+  }
+  return _impl_.version_;
+}
+inline ::proto::SyncdVersion* SyncdSnapshot::mutable_version() {
+  ::proto::SyncdVersion* _msg = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.version)
+  return _msg;
+}
+inline void SyncdSnapshot::set_allocated_version(::proto::SyncdVersion* version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.version_;
+  }
+  if (version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
+    if (message_arena != submessage_arena) {
+      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, version, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_ = version;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.version)
+}
+
+// repeated .proto.SyncdRecord records = 2;
+inline int SyncdSnapshot::_internal_records_size() const {
+  return _impl_.records_.size();
+}
+inline int SyncdSnapshot::records_size() const {
+  return _internal_records_size();
+}
+inline void SyncdSnapshot::clear_records() {
+  _impl_.records_.Clear();
+}
+inline ::proto::SyncdRecord* SyncdSnapshot::mutable_records(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.records)
+  return _impl_.records_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >*
+SyncdSnapshot::mutable_records() {
+  // @@protoc_insertion_point(field_mutable_list:proto.SyncdSnapshot.records)
+  return &_impl_.records_;
+}
+inline const ::proto::SyncdRecord& SyncdSnapshot::_internal_records(int index) const {
+  return _impl_.records_.Get(index);
+}
+inline const ::proto::SyncdRecord& SyncdSnapshot::records(int index) const {
+  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.records)
+  return _internal_records(index);
+}
+inline ::proto::SyncdRecord* SyncdSnapshot::_internal_add_records() {
+  return _impl_.records_.Add();
+}
+inline ::proto::SyncdRecord* SyncdSnapshot::add_records() {
+  ::proto::SyncdRecord* _add = _internal_add_records();
+  // @@protoc_insertion_point(field_add:proto.SyncdSnapshot.records)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >&
+SyncdSnapshot::records() const {
+  // @@protoc_insertion_point(field_list:proto.SyncdSnapshot.records)
+  return _impl_.records_;
+}
+
+// optional bytes mac = 3;
+inline bool SyncdSnapshot::_internal_has_mac() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncdSnapshot::has_mac() const {
+  return _internal_has_mac();
+}
+inline void SyncdSnapshot::clear_mac() {
+  _impl_.mac_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncdSnapshot::mac() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.mac)
+  return _internal_mac();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncdSnapshot::set_mac(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.mac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncdSnapshot.mac)
+}
+inline std::string* SyncdSnapshot::mutable_mac() {
+  std::string* _s = _internal_mutable_mac();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.mac)
+  return _s;
+}
+inline const std::string& SyncdSnapshot::_internal_mac() const {
+  return _impl_.mac_.Get();
+}
+inline void SyncdSnapshot::_internal_set_mac(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.mac_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncdSnapshot::_internal_mutable_mac() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.mac_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncdSnapshot::release_mac() {
+  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.mac)
+  if (!_internal_has_mac()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.mac_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mac_.IsDefault()) {
+    _impl_.mac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncdSnapshot::set_allocated_mac(std::string* mac) {
+  if (mac != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.mac_.SetAllocated(mac, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mac_.IsDefault()) {
+    _impl_.mac_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.mac)
+}
+
+// optional .proto.KeyId keyId = 4;
+inline bool SyncdSnapshot::_internal_has_keyid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
+  return value;
+}
+inline bool SyncdSnapshot::has_keyid() const {
+  return _internal_has_keyid();
+}
+inline void SyncdSnapshot::clear_keyid() {
+  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::proto::KeyId& SyncdSnapshot::_internal_keyid() const {
+  const ::proto::KeyId* p = _impl_.keyid_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
+      ::proto::_KeyId_default_instance_);
+}
+inline const ::proto::KeyId& SyncdSnapshot::keyid() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.keyId)
+  return _internal_keyid();
+}
+inline void SyncdSnapshot::unsafe_arena_set_allocated_keyid(
+    ::proto::KeyId* keyid) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
+  }
+  _impl_.keyid_ = keyid;
+  if (keyid) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.keyId)
+}
+inline ::proto::KeyId* SyncdSnapshot::release_keyid() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::KeyId* SyncdSnapshot::unsafe_arena_release_keyid() {
+  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.keyId)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::proto::KeyId* temp = _impl_.keyid_;
+  _impl_.keyid_ = nullptr;
+  return temp;
+}
+inline ::proto::KeyId* SyncdSnapshot::_internal_mutable_keyid() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.keyid_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
+    _impl_.keyid_ = p;
+  }
+  return _impl_.keyid_;
+}
+inline ::proto::KeyId* SyncdSnapshot::mutable_keyid() {
+  ::proto::KeyId* _msg = _internal_mutable_keyid();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.keyId)
+  return _msg;
+}
+inline void SyncdSnapshot::set_allocated_keyid(::proto::KeyId* keyid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keyid_;
+  }
+  if (keyid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
+    if (message_arena != submessage_arena) {
+      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keyid, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.keyid_ = keyid;
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.keyId)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdValue
+
+// optional bytes blob = 1;
+inline bool SyncdValue::_internal_has_blob() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncdValue::has_blob() const {
+  return _internal_has_blob();
+}
+inline void SyncdValue::clear_blob() {
+  _impl_.blob_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SyncdValue::blob() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdValue.blob)
+  return _internal_blob();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SyncdValue::set_blob(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.blob_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.SyncdValue.blob)
+}
+inline std::string* SyncdValue::mutable_blob() {
+  std::string* _s = _internal_mutable_blob();
+  // @@protoc_insertion_point(field_mutable:proto.SyncdValue.blob)
+  return _s;
+}
+inline const std::string& SyncdValue::_internal_blob() const {
+  return _impl_.blob_.Get();
+}
+inline void SyncdValue::_internal_set_blob(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.blob_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SyncdValue::_internal_mutable_blob() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.blob_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SyncdValue::release_blob() {
+  // @@protoc_insertion_point(field_release:proto.SyncdValue.blob)
+  if (!_internal_has_blob()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.blob_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blob_.IsDefault()) {
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SyncdValue::set_allocated_blob(std::string* blob) {
+  if (blob != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.blob_.SetAllocated(blob, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blob_.IsDefault()) {
+    _impl_.blob_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.SyncdValue.blob)
+}
+
+// -------------------------------------------------------------------
+
+// SyncdVersion
+
+// optional uint64 version = 1;
+inline bool SyncdVersion::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SyncdVersion::has_version() const {
+  return _internal_has_version();
+}
+inline void SyncdVersion::clear_version() {
+  _impl_.version_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t SyncdVersion::_internal_version() const {
+  return _impl_.version_;
+}
+inline uint64_t SyncdVersion::version() const {
+  // @@protoc_insertion_point(field_get:proto.SyncdVersion.version)
+  return _internal_version();
+}
+inline void SyncdVersion::_internal_set_version(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.version_ = value;
+}
+inline void SyncdVersion::set_version(uint64_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:proto.SyncdVersion.version)
+}
+
+// -------------------------------------------------------------------
+
+// TemplateButton_CallButton
+
+// optional .proto.Message.HighlyStructuredMessage displayText = 1;
+inline bool TemplateButton_CallButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
+  return value;
+}
+inline bool TemplateButton_CallButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void TemplateButton_CallButton::clear_displaytext() {
+  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_displaytext() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.displayText)
+  return _internal_displaytext();
+}
+inline void TemplateButton_CallButton::unsafe_arena_set_allocated_displaytext(
+    ::proto::Message_HighlyStructuredMessage* displaytext) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
+  }
+  _impl_.displaytext_ = displaytext;
+  if (displaytext) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.displayText)
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_displaytext() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.displayText)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.displaytext_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.displaytext_ = p;
+  }
+  return _impl_.displaytext_;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_displaytext() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.displayText)
+  return _msg;
+}
+inline void TemplateButton_CallButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.displaytext_;
+  }
+  if (displaytext) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
+    if (message_arena != submessage_arena) {
+      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, displaytext, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_ = displaytext;
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.displayText)
+}
+
+// optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
+inline bool TemplateButton_CallButton::_internal_has_phonenumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.phonenumber_ != nullptr);
+  return value;
+}
+inline bool TemplateButton_CallButton::has_phonenumber() const {
+  return _internal_has_phonenumber();
+}
+inline void TemplateButton_CallButton::clear_phonenumber() {
+  if (_impl_.phonenumber_ != nullptr) _impl_.phonenumber_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_phonenumber() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.phonenumber_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::phonenumber() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.phoneNumber)
+  return _internal_phonenumber();
+}
+inline void TemplateButton_CallButton::unsafe_arena_set_allocated_phonenumber(
+    ::proto::Message_HighlyStructuredMessage* phonenumber) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phonenumber_);
+  }
+  _impl_.phonenumber_ = phonenumber;
+  if (phonenumber) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.phoneNumber)
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_phonenumber() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_;
+  _impl_.phonenumber_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_phonenumber() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.phoneNumber)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_;
+  _impl_.phonenumber_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_phonenumber() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.phonenumber_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.phonenumber_ = p;
+  }
+  return _impl_.phonenumber_;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_phonenumber() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_phonenumber();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.phoneNumber)
+  return _msg;
+}
+inline void TemplateButton_CallButton::set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.phonenumber_;
+  }
+  if (phonenumber) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phonenumber);
+    if (message_arena != submessage_arena) {
+      phonenumber = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, phonenumber, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.phonenumber_ = phonenumber;
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.phoneNumber)
+}
+
+// -------------------------------------------------------------------
+
+// TemplateButton_QuickReplyButton
+
+// optional .proto.Message.HighlyStructuredMessage displayText = 1;
+inline bool TemplateButton_QuickReplyButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
+  return value;
+}
+inline bool TemplateButton_QuickReplyButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void TemplateButton_QuickReplyButton::clear_displaytext() {
+  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::_internal_displaytext() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.displayText)
+  return _internal_displaytext();
+}
+inline void TemplateButton_QuickReplyButton::unsafe_arena_set_allocated_displaytext(
+    ::proto::Message_HighlyStructuredMessage* displaytext) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
+  }
+  _impl_.displaytext_ = displaytext;
+  if (displaytext) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.QuickReplyButton.displayText)
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::release_displaytext() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::unsafe_arena_release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.displayText)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.displaytext_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.displaytext_ = p;
+  }
+  return _impl_.displaytext_;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::mutable_displaytext() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.displayText)
+  return _msg;
+}
+inline void TemplateButton_QuickReplyButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.displaytext_;
+  }
+  if (displaytext) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
+    if (message_arena != submessage_arena) {
+      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, displaytext, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.displaytext_ = displaytext;
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.displayText)
+}
+
+// optional string id = 2;
+inline bool TemplateButton_QuickReplyButton::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool TemplateButton_QuickReplyButton::has_id() const {
+  return _internal_has_id();
+}
+inline void TemplateButton_QuickReplyButton::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& TemplateButton_QuickReplyButton::id() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void TemplateButton_QuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.TemplateButton.QuickReplyButton.id)
+}
+inline std::string* TemplateButton_QuickReplyButton::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.id)
+  return _s;
+}
+inline const std::string& TemplateButton_QuickReplyButton::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void TemplateButton_QuickReplyButton::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* TemplateButton_QuickReplyButton::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* TemplateButton_QuickReplyButton::release_id() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void TemplateButton_QuickReplyButton::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.id)
+}
+
+// -------------------------------------------------------------------
+
+// TemplateButton_URLButton
+
+// optional .proto.Message.HighlyStructuredMessage displayText = 1;
+inline bool TemplateButton_URLButton::_internal_has_displaytext() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
+  return value;
+}
+inline bool TemplateButton_URLButton::has_displaytext() const {
+  return _internal_has_displaytext();
+}
+inline void TemplateButton_URLButton::clear_displaytext() {
+  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_displaytext() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::displaytext() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.displayText)
+  return _internal_displaytext();
+}
+inline void TemplateButton_URLButton::unsafe_arena_set_allocated_displaytext(
+    ::proto::Message_HighlyStructuredMessage* displaytext) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
+  }
+  _impl_.displaytext_ = displaytext;
+  if (displaytext) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.displayText)
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_displaytext() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_displaytext() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.displayText)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
+  _impl_.displaytext_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_displaytext() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.displaytext_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.displaytext_ = p;
+  }
+  return _impl_.displaytext_;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_displaytext() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.displayText)
+  return _msg;
+}
+inline void TemplateButton_URLButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.displaytext_;
+  }
+  if (displaytext) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
+    if (message_arena != submessage_arena) {
+      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, displaytext, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.displaytext_ = displaytext;
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.displayText)
+}
+
+// optional .proto.Message.HighlyStructuredMessage url = 2;
+inline bool TemplateButton_URLButton::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.url_ != nullptr);
+  return value;
+}
+inline bool TemplateButton_URLButton::has_url() const {
+  return _internal_has_url();
+}
+inline void TemplateButton_URLButton::clear_url() {
+  if (_impl_.url_ != nullptr) _impl_.url_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_url() const {
+  const ::proto::Message_HighlyStructuredMessage* p = _impl_.url_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
+      ::proto::_Message_HighlyStructuredMessage_default_instance_);
+}
+inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::url() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.url)
+  return _internal_url();
+}
+inline void TemplateButton_URLButton::unsafe_arena_set_allocated_url(
+    ::proto::Message_HighlyStructuredMessage* url) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.url_);
+  }
+  _impl_.url_ = url;
+  if (url) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.url)
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_url() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_;
+  _impl_.url_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_url() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.url)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_;
+  _impl_.url_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.url_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
+    _impl_.url_ = p;
+  }
+  return _impl_.url_;
+}
+inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_url() {
+  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.url)
+  return _msg;
+}
+inline void TemplateButton_URLButton::set_allocated_url(::proto::Message_HighlyStructuredMessage* url) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.url_;
+  }
+  if (url) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(url);
+    if (message_arena != submessage_arena) {
+      url = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, url, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_ = url;
+  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.url)
+}
+
+// -------------------------------------------------------------------
+
+// TemplateButton
+
+// optional uint32 index = 4;
+inline bool TemplateButton::_internal_has_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool TemplateButton::has_index() const {
+  return _internal_has_index();
+}
+inline void TemplateButton::clear_index() {
+  _impl_.index_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint32_t TemplateButton::_internal_index() const {
+  return _impl_.index_;
+}
+inline uint32_t TemplateButton::index() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.index)
+  return _internal_index();
+}
+inline void TemplateButton::_internal_set_index(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.index_ = value;
+}
+inline void TemplateButton::set_index(uint32_t value) {
+  _internal_set_index(value);
+  // @@protoc_insertion_point(field_set:proto.TemplateButton.index)
+}
+
+// .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
+inline bool TemplateButton::_internal_has_quickreplybutton() const {
+  return button_case() == kQuickReplyButton;
+}
+inline bool TemplateButton::has_quickreplybutton() const {
+  return _internal_has_quickreplybutton();
+}
+inline void TemplateButton::set_has_quickreplybutton() {
+  _impl_._oneof_case_[0] = kQuickReplyButton;
+}
+inline void TemplateButton::clear_quickreplybutton() {
+  if (_internal_has_quickreplybutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.button_.quickreplybutton_;
+    }
+    clear_has_button();
+  }
+}
+inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::release_quickreplybutton() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.quickReplyButton)
+  if (_internal_has_quickreplybutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.button_.quickreplybutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::_internal_quickreplybutton() const {
+  return _internal_has_quickreplybutton()
+      ? *_impl_.button_.quickreplybutton_
+      : reinterpret_cast< ::proto::TemplateButton_QuickReplyButton&>(::proto::_TemplateButton_QuickReplyButton_default_instance_);
+}
+inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::quickreplybutton() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.quickReplyButton)
+  return _internal_quickreplybutton();
+}
+inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::unsafe_arena_release_quickreplybutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.quickReplyButton)
+  if (_internal_has_quickreplybutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_;
+    _impl_.button_.quickreplybutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) {
+  clear_button();
+  if (quickreplybutton) {
+    set_has_quickreplybutton();
+    _impl_.button_.quickreplybutton_ = quickreplybutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.quickReplyButton)
+}
+inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::_internal_mutable_quickreplybutton() {
+  if (!_internal_has_quickreplybutton()) {
+    clear_button();
+    set_has_quickreplybutton();
+    _impl_.button_.quickreplybutton_ = CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(GetArenaForAllocation());
+  }
+  return _impl_.button_.quickreplybutton_;
+}
+inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::mutable_quickreplybutton() {
+  ::proto::TemplateButton_QuickReplyButton* _msg = _internal_mutable_quickreplybutton();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.quickReplyButton)
+  return _msg;
+}
+
+// .proto.TemplateButton.URLButton urlButton = 2;
+inline bool TemplateButton::_internal_has_urlbutton() const {
+  return button_case() == kUrlButton;
+}
+inline bool TemplateButton::has_urlbutton() const {
+  return _internal_has_urlbutton();
+}
+inline void TemplateButton::set_has_urlbutton() {
+  _impl_._oneof_case_[0] = kUrlButton;
+}
+inline void TemplateButton::clear_urlbutton() {
+  if (_internal_has_urlbutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.button_.urlbutton_;
+    }
+    clear_has_button();
+  }
+}
+inline ::proto::TemplateButton_URLButton* TemplateButton::release_urlbutton() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.urlButton)
+  if (_internal_has_urlbutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.button_.urlbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::TemplateButton_URLButton& TemplateButton::_internal_urlbutton() const {
+  return _internal_has_urlbutton()
+      ? *_impl_.button_.urlbutton_
+      : reinterpret_cast< ::proto::TemplateButton_URLButton&>(::proto::_TemplateButton_URLButton_default_instance_);
+}
+inline const ::proto::TemplateButton_URLButton& TemplateButton::urlbutton() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.urlButton)
+  return _internal_urlbutton();
+}
+inline ::proto::TemplateButton_URLButton* TemplateButton::unsafe_arena_release_urlbutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.urlButton)
+  if (_internal_has_urlbutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_;
+    _impl_.button_.urlbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) {
+  clear_button();
+  if (urlbutton) {
+    set_has_urlbutton();
+    _impl_.button_.urlbutton_ = urlbutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.urlButton)
+}
+inline ::proto::TemplateButton_URLButton* TemplateButton::_internal_mutable_urlbutton() {
+  if (!_internal_has_urlbutton()) {
+    clear_button();
+    set_has_urlbutton();
+    _impl_.button_.urlbutton_ = CreateMaybeMessage< ::proto::TemplateButton_URLButton >(GetArenaForAllocation());
+  }
+  return _impl_.button_.urlbutton_;
+}
+inline ::proto::TemplateButton_URLButton* TemplateButton::mutable_urlbutton() {
+  ::proto::TemplateButton_URLButton* _msg = _internal_mutable_urlbutton();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.urlButton)
+  return _msg;
+}
+
+// .proto.TemplateButton.CallButton callButton = 3;
+inline bool TemplateButton::_internal_has_callbutton() const {
+  return button_case() == kCallButton;
+}
+inline bool TemplateButton::has_callbutton() const {
+  return _internal_has_callbutton();
+}
+inline void TemplateButton::set_has_callbutton() {
+  _impl_._oneof_case_[0] = kCallButton;
+}
+inline void TemplateButton::clear_callbutton() {
+  if (_internal_has_callbutton()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.button_.callbutton_;
+    }
+    clear_has_button();
+  }
+}
+inline ::proto::TemplateButton_CallButton* TemplateButton::release_callbutton() {
+  // @@protoc_insertion_point(field_release:proto.TemplateButton.callButton)
+  if (_internal_has_callbutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.button_.callbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::proto::TemplateButton_CallButton& TemplateButton::_internal_callbutton() const {
+  return _internal_has_callbutton()
+      ? *_impl_.button_.callbutton_
+      : reinterpret_cast< ::proto::TemplateButton_CallButton&>(::proto::_TemplateButton_CallButton_default_instance_);
+}
+inline const ::proto::TemplateButton_CallButton& TemplateButton::callbutton() const {
+  // @@protoc_insertion_point(field_get:proto.TemplateButton.callButton)
+  return _internal_callbutton();
+}
+inline ::proto::TemplateButton_CallButton* TemplateButton::unsafe_arena_release_callbutton() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.callButton)
+  if (_internal_has_callbutton()) {
+    clear_has_button();
+    ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_;
+    _impl_.button_.callbutton_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TemplateButton::unsafe_arena_set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) {
+  clear_button();
+  if (callbutton) {
+    set_has_callbutton();
+    _impl_.button_.callbutton_ = callbutton;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.callButton)
+}
+inline ::proto::TemplateButton_CallButton* TemplateButton::_internal_mutable_callbutton() {
+  if (!_internal_has_callbutton()) {
+    clear_button();
+    set_has_callbutton();
+    _impl_.button_.callbutton_ = CreateMaybeMessage< ::proto::TemplateButton_CallButton >(GetArenaForAllocation());
+  }
+  return _impl_.button_.callbutton_;
+}
+inline ::proto::TemplateButton_CallButton* TemplateButton::mutable_callbutton() {
+  ::proto::TemplateButton_CallButton* _msg = _internal_mutable_callbutton();
+  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.callButton)
+  return _msg;
+}
+
+inline bool TemplateButton::has_button() const {
+  return button_case() != BUTTON_NOT_SET;
+}
+inline void TemplateButton::clear_has_button() {
+  _impl_._oneof_case_[0] = BUTTON_NOT_SET;
+}
+inline TemplateButton::ButtonCase TemplateButton::button_case() const {
+  return TemplateButton::ButtonCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// UserReceipt
+
+// required string userJid = 1;
+inline bool UserReceipt::_internal_has_userjid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool UserReceipt::has_userjid() const {
+  return _internal_has_userjid();
+}
+inline void UserReceipt::clear_userjid() {
+  _impl_.userjid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& UserReceipt::userjid() const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.userJid)
+  return _internal_userjid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void UserReceipt::set_userjid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.userJid)
+}
+inline std::string* UserReceipt::mutable_userjid() {
+  std::string* _s = _internal_mutable_userjid();
+  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.userJid)
+  return _s;
+}
+inline const std::string& UserReceipt::_internal_userjid() const {
+  return _impl_.userjid_.Get();
+}
+inline void UserReceipt::_internal_set_userjid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.userjid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UserReceipt::_internal_mutable_userjid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.userjid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UserReceipt::release_userjid() {
+  // @@protoc_insertion_point(field_release:proto.UserReceipt.userJid)
+  if (!_internal_has_userjid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.userjid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void UserReceipt::set_allocated_userjid(std::string* userjid) {
+  if (userjid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.userjid_.IsDefault()) {
+    _impl_.userjid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.UserReceipt.userJid)
+}
+
+// optional int64 receiptTimestamp = 2;
+inline bool UserReceipt::_internal_has_receipttimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool UserReceipt::has_receipttimestamp() const {
+  return _internal_has_receipttimestamp();
+}
+inline void UserReceipt::clear_receipttimestamp() {
+  _impl_.receipttimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t UserReceipt::_internal_receipttimestamp() const {
+  return _impl_.receipttimestamp_;
+}
+inline int64_t UserReceipt::receipttimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.receiptTimestamp)
+  return _internal_receipttimestamp();
+}
+inline void UserReceipt::_internal_set_receipttimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.receipttimestamp_ = value;
+}
+inline void UserReceipt::set_receipttimestamp(int64_t value) {
+  _internal_set_receipttimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.receiptTimestamp)
+}
+
+// optional int64 readTimestamp = 3;
+inline bool UserReceipt::_internal_has_readtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool UserReceipt::has_readtimestamp() const {
+  return _internal_has_readtimestamp();
+}
+inline void UserReceipt::clear_readtimestamp() {
+  _impl_.readtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t UserReceipt::_internal_readtimestamp() const {
+  return _impl_.readtimestamp_;
+}
+inline int64_t UserReceipt::readtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.readTimestamp)
+  return _internal_readtimestamp();
+}
+inline void UserReceipt::_internal_set_readtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.readtimestamp_ = value;
+}
+inline void UserReceipt::set_readtimestamp(int64_t value) {
+  _internal_set_readtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.readTimestamp)
+}
+
+// optional int64 playedTimestamp = 4;
+inline bool UserReceipt::_internal_has_playedtimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool UserReceipt::has_playedtimestamp() const {
+  return _internal_has_playedtimestamp();
+}
+inline void UserReceipt::clear_playedtimestamp() {
+  _impl_.playedtimestamp_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t UserReceipt::_internal_playedtimestamp() const {
+  return _impl_.playedtimestamp_;
+}
+inline int64_t UserReceipt::playedtimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.playedTimestamp)
+  return _internal_playedtimestamp();
+}
+inline void UserReceipt::_internal_set_playedtimestamp(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.playedtimestamp_ = value;
+}
+inline void UserReceipt::set_playedtimestamp(int64_t value) {
+  _internal_set_playedtimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.playedTimestamp)
+}
+
+// repeated string pendingDeviceJid = 5;
+inline int UserReceipt::_internal_pendingdevicejid_size() const {
+  return _impl_.pendingdevicejid_.size();
+}
+inline int UserReceipt::pendingdevicejid_size() const {
+  return _internal_pendingdevicejid_size();
+}
+inline void UserReceipt::clear_pendingdevicejid() {
+  _impl_.pendingdevicejid_.Clear();
+}
+inline std::string* UserReceipt::add_pendingdevicejid() {
+  std::string* _s = _internal_add_pendingdevicejid();
+  // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.pendingDeviceJid)
+  return _s;
+}
+inline const std::string& UserReceipt::_internal_pendingdevicejid(int index) const {
+  return _impl_.pendingdevicejid_.Get(index);
+}
+inline const std::string& UserReceipt::pendingdevicejid(int index) const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.pendingDeviceJid)
+  return _internal_pendingdevicejid(index);
+}
+inline std::string* UserReceipt::mutable_pendingdevicejid(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.pendingDeviceJid)
+  return _impl_.pendingdevicejid_.Mutable(index);
+}
+inline void UserReceipt::set_pendingdevicejid(int index, const std::string& value) {
+  _impl_.pendingdevicejid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::set_pendingdevicejid(int index, std::string&& value) {
+  _impl_.pendingdevicejid_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::set_pendingdevicejid(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.pendingdevicejid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::set_pendingdevicejid(int index, const char* value, size_t size) {
+  _impl_.pendingdevicejid_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.pendingDeviceJid)
+}
+inline std::string* UserReceipt::_internal_add_pendingdevicejid() {
+  return _impl_.pendingdevicejid_.Add();
+}
+inline void UserReceipt::add_pendingdevicejid(const std::string& value) {
+  _impl_.pendingdevicejid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::add_pendingdevicejid(std::string&& value) {
+  _impl_.pendingdevicejid_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::add_pendingdevicejid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.pendingdevicejid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.UserReceipt.pendingDeviceJid)
+}
+inline void UserReceipt::add_pendingdevicejid(const char* value, size_t size) {
+  _impl_.pendingdevicejid_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.pendingDeviceJid)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+UserReceipt::pendingdevicejid() const {
+  // @@protoc_insertion_point(field_list:proto.UserReceipt.pendingDeviceJid)
+  return _impl_.pendingdevicejid_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+UserReceipt::mutable_pendingdevicejid() {
+  // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.pendingDeviceJid)
+  return &_impl_.pendingdevicejid_;
+}
+
+// repeated string deliveredDeviceJid = 6;
+inline int UserReceipt::_internal_delivereddevicejid_size() const {
+  return _impl_.delivereddevicejid_.size();
+}
+inline int UserReceipt::delivereddevicejid_size() const {
+  return _internal_delivereddevicejid_size();
+}
+inline void UserReceipt::clear_delivereddevicejid() {
+  _impl_.delivereddevicejid_.Clear();
+}
+inline std::string* UserReceipt::add_delivereddevicejid() {
+  std::string* _s = _internal_add_delivereddevicejid();
+  // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.deliveredDeviceJid)
+  return _s;
+}
+inline const std::string& UserReceipt::_internal_delivereddevicejid(int index) const {
+  return _impl_.delivereddevicejid_.Get(index);
+}
+inline const std::string& UserReceipt::delivereddevicejid(int index) const {
+  // @@protoc_insertion_point(field_get:proto.UserReceipt.deliveredDeviceJid)
+  return _internal_delivereddevicejid(index);
+}
+inline std::string* UserReceipt::mutable_delivereddevicejid(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.deliveredDeviceJid)
+  return _impl_.delivereddevicejid_.Mutable(index);
+}
+inline void UserReceipt::set_delivereddevicejid(int index, const std::string& value) {
+  _impl_.delivereddevicejid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::set_delivereddevicejid(int index, std::string&& value) {
+  _impl_.delivereddevicejid_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::set_delivereddevicejid(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.delivereddevicejid_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::set_delivereddevicejid(int index, const char* value, size_t size) {
+  _impl_.delivereddevicejid_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.deliveredDeviceJid)
+}
+inline std::string* UserReceipt::_internal_add_delivereddevicejid() {
+  return _impl_.delivereddevicejid_.Add();
+}
+inline void UserReceipt::add_delivereddevicejid(const std::string& value) {
+  _impl_.delivereddevicejid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::add_delivereddevicejid(std::string&& value) {
+  _impl_.delivereddevicejid_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::add_delivereddevicejid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.delivereddevicejid_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.UserReceipt.deliveredDeviceJid)
+}
+inline void UserReceipt::add_delivereddevicejid(const char* value, size_t size) {
+  _impl_.delivereddevicejid_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.deliveredDeviceJid)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+UserReceipt::delivereddevicejid() const {
+  // @@protoc_insertion_point(field_list:proto.UserReceipt.deliveredDeviceJid)
+  return _impl_.delivereddevicejid_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+UserReceipt::mutable_delivereddevicejid() {
+  // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.deliveredDeviceJid)
+  return &_impl_.delivereddevicejid_;
+}
+
+// -------------------------------------------------------------------
+
+// VerifiedNameCertificate_Details
+
+// optional uint64 serial = 1;
+inline bool VerifiedNameCertificate_Details::_internal_has_serial() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate_Details::has_serial() const {
+  return _internal_has_serial();
+}
+inline void VerifiedNameCertificate_Details::clear_serial() {
+  _impl_.serial_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint64_t VerifiedNameCertificate_Details::_internal_serial() const {
+  return _impl_.serial_;
+}
+inline uint64_t VerifiedNameCertificate_Details::serial() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.serial)
+  return _internal_serial();
+}
+inline void VerifiedNameCertificate_Details::_internal_set_serial(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.serial_ = value;
+}
+inline void VerifiedNameCertificate_Details::set_serial(uint64_t value) {
+  _internal_set_serial(value);
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.serial)
+}
+
+// optional string issuer = 2;
+inline bool VerifiedNameCertificate_Details::_internal_has_issuer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate_Details::has_issuer() const {
+  return _internal_has_issuer();
+}
+inline void VerifiedNameCertificate_Details::clear_issuer() {
+  _impl_.issuer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VerifiedNameCertificate_Details::issuer() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issuer)
+  return _internal_issuer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VerifiedNameCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.issuer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issuer)
+}
+inline std::string* VerifiedNameCertificate_Details::mutable_issuer() {
+  std::string* _s = _internal_mutable_issuer();
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.issuer)
+  return _s;
+}
+inline const std::string& VerifiedNameCertificate_Details::_internal_issuer() const {
+  return _impl_.issuer_.Get();
+}
+inline void VerifiedNameCertificate_Details::_internal_set_issuer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.issuer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate_Details::_internal_mutable_issuer() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.issuer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate_Details::release_issuer() {
+  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.issuer)
+  if (!_internal_has_issuer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.issuer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.issuer_.IsDefault()) {
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void VerifiedNameCertificate_Details::set_allocated_issuer(std::string* issuer) {
+  if (issuer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.issuer_.IsDefault()) {
+    _impl_.issuer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.issuer)
+}
+
+// optional string verifiedName = 4;
+inline bool VerifiedNameCertificate_Details::_internal_has_verifiedname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate_Details::has_verifiedname() const {
+  return _internal_has_verifiedname();
+}
+inline void VerifiedNameCertificate_Details::clear_verifiedname() {
+  _impl_.verifiedname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VerifiedNameCertificate_Details::verifiedname() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.verifiedName)
+  return _internal_verifiedname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VerifiedNameCertificate_Details::set_verifiedname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.verifiedname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.verifiedName)
+}
+inline std::string* VerifiedNameCertificate_Details::mutable_verifiedname() {
+  std::string* _s = _internal_mutable_verifiedname();
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.verifiedName)
+  return _s;
+}
+inline const std::string& VerifiedNameCertificate_Details::_internal_verifiedname() const {
+  return _impl_.verifiedname_.Get();
+}
+inline void VerifiedNameCertificate_Details::_internal_set_verifiedname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.verifiedname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate_Details::_internal_mutable_verifiedname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.verifiedname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate_Details::release_verifiedname() {
+  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.verifiedName)
+  if (!_internal_has_verifiedname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.verifiedname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedname_.IsDefault()) {
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void VerifiedNameCertificate_Details::set_allocated_verifiedname(std::string* verifiedname) {
+  if (verifiedname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedname_.IsDefault()) {
+    _impl_.verifiedname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.verifiedName)
+}
+
+// repeated .proto.LocalizedName localizedNames = 8;
+inline int VerifiedNameCertificate_Details::_internal_localizednames_size() const {
+  return _impl_.localizednames_.size();
+}
+inline int VerifiedNameCertificate_Details::localizednames_size() const {
+  return _internal_localizednames_size();
+}
+inline void VerifiedNameCertificate_Details::clear_localizednames() {
+  _impl_.localizednames_.Clear();
+}
+inline ::proto::LocalizedName* VerifiedNameCertificate_Details::mutable_localizednames(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.localizedNames)
+  return _impl_.localizednames_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >*
+VerifiedNameCertificate_Details::mutable_localizednames() {
+  // @@protoc_insertion_point(field_mutable_list:proto.VerifiedNameCertificate.Details.localizedNames)
+  return &_impl_.localizednames_;
+}
+inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::_internal_localizednames(int index) const {
+  return _impl_.localizednames_.Get(index);
+}
+inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::localizednames(int index) const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.localizedNames)
+  return _internal_localizednames(index);
+}
+inline ::proto::LocalizedName* VerifiedNameCertificate_Details::_internal_add_localizednames() {
+  return _impl_.localizednames_.Add();
+}
+inline ::proto::LocalizedName* VerifiedNameCertificate_Details::add_localizednames() {
+  ::proto::LocalizedName* _add = _internal_add_localizednames();
+  // @@protoc_insertion_point(field_add:proto.VerifiedNameCertificate.Details.localizedNames)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >&
+VerifiedNameCertificate_Details::localizednames() const {
+  // @@protoc_insertion_point(field_list:proto.VerifiedNameCertificate.Details.localizedNames)
+  return _impl_.localizednames_;
+}
+
+// optional uint64 issueTime = 10;
+inline bool VerifiedNameCertificate_Details::_internal_has_issuetime() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate_Details::has_issuetime() const {
+  return _internal_has_issuetime();
+}
+inline void VerifiedNameCertificate_Details::clear_issuetime() {
+  _impl_.issuetime_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t VerifiedNameCertificate_Details::_internal_issuetime() const {
+  return _impl_.issuetime_;
+}
+inline uint64_t VerifiedNameCertificate_Details::issuetime() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issueTime)
+  return _internal_issuetime();
+}
+inline void VerifiedNameCertificate_Details::_internal_set_issuetime(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.issuetime_ = value;
+}
+inline void VerifiedNameCertificate_Details::set_issuetime(uint64_t value) {
+  _internal_set_issuetime(value);
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issueTime)
+}
+
+// -------------------------------------------------------------------
+
+// VerifiedNameCertificate
+
+// optional bytes details = 1;
+inline bool VerifiedNameCertificate::_internal_has_details() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate::has_details() const {
+  return _internal_has_details();
+}
+inline void VerifiedNameCertificate::clear_details() {
+  _impl_.details_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VerifiedNameCertificate::details() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.details)
+  return _internal_details();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VerifiedNameCertificate::set_details(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.details)
+}
+inline std::string* VerifiedNameCertificate::mutable_details() {
+  std::string* _s = _internal_mutable_details();
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.details)
+  return _s;
+}
+inline const std::string& VerifiedNameCertificate::_internal_details() const {
+  return _impl_.details_.Get();
+}
+inline void VerifiedNameCertificate::_internal_set_details(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.details_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::_internal_mutable_details() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.details_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::release_details() {
+  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.details)
+  if (!_internal_has_details()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.details_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void VerifiedNameCertificate::set_allocated_details(std::string* details) {
+  if (details != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.details_.IsDefault()) {
+    _impl_.details_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.details)
+}
+
+// optional bytes signature = 2;
+inline bool VerifiedNameCertificate::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate::has_signature() const {
+  return _internal_has_signature();
+}
+inline void VerifiedNameCertificate::clear_signature() {
+  _impl_.signature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VerifiedNameCertificate::signature() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VerifiedNameCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.signature)
+}
+inline std::string* VerifiedNameCertificate::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.signature)
+  return _s;
+}
+inline const std::string& VerifiedNameCertificate::_internal_signature() const {
+  return _impl_.signature_.Get();
+}
+inline void VerifiedNameCertificate::_internal_set_signature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.signature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.signature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::release_signature() {
+  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.signature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void VerifiedNameCertificate::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.signature_.IsDefault()) {
+    _impl_.signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.signature)
+}
+
+// optional bytes serverSignature = 3;
+inline bool VerifiedNameCertificate::_internal_has_serversignature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool VerifiedNameCertificate::has_serversignature() const {
+  return _internal_has_serversignature();
+}
+inline void VerifiedNameCertificate::clear_serversignature() {
+  _impl_.serversignature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& VerifiedNameCertificate::serversignature() const {
+  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.serverSignature)
+  return _internal_serversignature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VerifiedNameCertificate::set_serversignature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.serversignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.serverSignature)
+}
+inline std::string* VerifiedNameCertificate::mutable_serversignature() {
+  std::string* _s = _internal_mutable_serversignature();
+  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.serverSignature)
+  return _s;
+}
+inline const std::string& VerifiedNameCertificate::_internal_serversignature() const {
+  return _impl_.serversignature_.Get();
+}
+inline void VerifiedNameCertificate::_internal_set_serversignature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.serversignature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::_internal_mutable_serversignature() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.serversignature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VerifiedNameCertificate::release_serversignature() {
+  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.serverSignature)
+  if (!_internal_has_serversignature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.serversignature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.serversignature_.IsDefault()) {
+    _impl_.serversignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void VerifiedNameCertificate::set_allocated_serversignature(std::string* serversignature) {
+  if (serversignature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.serversignature_.SetAllocated(serversignature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.serversignature_.IsDefault()) {
+    _impl_.serversignature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.serverSignature)
+}
+
+// -------------------------------------------------------------------
+
+// WallpaperSettings
+
+// optional string filename = 1;
+inline bool WallpaperSettings::_internal_has_filename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WallpaperSettings::has_filename() const {
+  return _internal_has_filename();
+}
+inline void WallpaperSettings::clear_filename() {
+  _impl_.filename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WallpaperSettings::filename() const {
+  // @@protoc_insertion_point(field_get:proto.WallpaperSettings.filename)
+  return _internal_filename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WallpaperSettings::set_filename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WallpaperSettings.filename)
+}
+inline std::string* WallpaperSettings::mutable_filename() {
+  std::string* _s = _internal_mutable_filename();
+  // @@protoc_insertion_point(field_mutable:proto.WallpaperSettings.filename)
+  return _s;
+}
+inline const std::string& WallpaperSettings::_internal_filename() const {
+  return _impl_.filename_.Get();
+}
+inline void WallpaperSettings::_internal_set_filename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.filename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WallpaperSettings::_internal_mutable_filename() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.filename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WallpaperSettings::release_filename() {
+  // @@protoc_insertion_point(field_release:proto.WallpaperSettings.filename)
+  if (!_internal_has_filename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.filename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filename_.IsDefault()) {
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WallpaperSettings::set_allocated_filename(std::string* filename) {
+  if (filename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.filename_.IsDefault()) {
+    _impl_.filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WallpaperSettings.filename)
+}
+
+// optional uint32 opacity = 2;
+inline bool WallpaperSettings::_internal_has_opacity() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WallpaperSettings::has_opacity() const {
+  return _internal_has_opacity();
+}
+inline void WallpaperSettings::clear_opacity() {
+  _impl_.opacity_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t WallpaperSettings::_internal_opacity() const {
+  return _impl_.opacity_;
+}
+inline uint32_t WallpaperSettings::opacity() const {
+  // @@protoc_insertion_point(field_get:proto.WallpaperSettings.opacity)
+  return _internal_opacity();
+}
+inline void WallpaperSettings::_internal_set_opacity(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.opacity_ = value;
+}
+inline void WallpaperSettings::set_opacity(uint32_t value) {
+  _internal_set_opacity(value);
+  // @@protoc_insertion_point(field_set:proto.WallpaperSettings.opacity)
+}
+
+// -------------------------------------------------------------------
+
+// WebFeatures
+
+// optional .proto.WebFeatures.Flag labelsDisplay = 1;
+inline bool WebFeatures::_internal_has_labelsdisplay() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_labelsdisplay() const {
+  return _internal_has_labelsdisplay();
+}
+inline void WebFeatures::clear_labelsdisplay() {
+  _impl_.labelsdisplay_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsdisplay() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsdisplay_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::labelsdisplay() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsDisplay)
+  return _internal_labelsdisplay();
+}
+inline void WebFeatures::_internal_set_labelsdisplay(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.labelsdisplay_ = value;
+}
+inline void WebFeatures::set_labelsdisplay(::proto::WebFeatures_Flag value) {
+  _internal_set_labelsdisplay(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsDisplay)
+}
+
+// optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
+inline bool WebFeatures::_internal_has_voipindividualoutgoing() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_voipindividualoutgoing() const {
+  return _internal_has_voipindividualoutgoing();
+}
+inline void WebFeatures::clear_voipindividualoutgoing() {
+  _impl_.voipindividualoutgoing_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualoutgoing() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualoutgoing_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::voipindividualoutgoing() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualOutgoing)
+  return _internal_voipindividualoutgoing();
+}
+inline void WebFeatures::_internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.voipindividualoutgoing_ = value;
+}
+inline void WebFeatures::set_voipindividualoutgoing(::proto::WebFeatures_Flag value) {
+  _internal_set_voipindividualoutgoing(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualOutgoing)
+}
+
+// optional .proto.WebFeatures.Flag groupsV3 = 3;
+inline bool WebFeatures::_internal_has_groupsv3() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_groupsv3() const {
+  return _internal_has_groupsv3();
+}
+inline void WebFeatures::clear_groupsv3() {
+  _impl_.groupsv3_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::groupsv3() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3)
+  return _internal_groupsv3();
+}
+inline void WebFeatures::_internal_set_groupsv3(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.groupsv3_ = value;
+}
+inline void WebFeatures::set_groupsv3(::proto::WebFeatures_Flag value) {
+  _internal_set_groupsv3(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3)
+}
+
+// optional .proto.WebFeatures.Flag groupsV3Create = 4;
+inline bool WebFeatures::_internal_has_groupsv3create() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_groupsv3create() const {
+  return _internal_has_groupsv3create();
+}
+inline void WebFeatures::clear_groupsv3create() {
+  _impl_.groupsv3create_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3create() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3create_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::groupsv3create() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3Create)
+  return _internal_groupsv3create();
+}
+inline void WebFeatures::_internal_set_groupsv3create(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.groupsv3create_ = value;
+}
+inline void WebFeatures::set_groupsv3create(::proto::WebFeatures_Flag value) {
+  _internal_set_groupsv3create(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3Create)
+}
+
+// optional .proto.WebFeatures.Flag changeNumberV2 = 5;
+inline bool WebFeatures::_internal_has_changenumberv2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_changenumberv2() const {
+  return _internal_has_changenumberv2();
+}
+inline void WebFeatures::clear_changenumberv2() {
+  _impl_.changenumberv2_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_changenumberv2() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.changenumberv2_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::changenumberv2() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.changeNumberV2)
+  return _internal_changenumberv2();
+}
+inline void WebFeatures::_internal_set_changenumberv2(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.changenumberv2_ = value;
+}
+inline void WebFeatures::set_changenumberv2(::proto::WebFeatures_Flag value) {
+  _internal_set_changenumberv2(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.changeNumberV2)
+}
+
+// optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
+inline bool WebFeatures::_internal_has_querystatusv3thumbnail() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_querystatusv3thumbnail() const {
+  return _internal_has_querystatusv3thumbnail();
+}
+inline void WebFeatures::clear_querystatusv3thumbnail() {
+  _impl_.querystatusv3thumbnail_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_querystatusv3thumbnail() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.querystatusv3thumbnail_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::querystatusv3thumbnail() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.queryStatusV3Thumbnail)
+  return _internal_querystatusv3thumbnail();
+}
+inline void WebFeatures::_internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.querystatusv3thumbnail_ = value;
+}
+inline void WebFeatures::set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) {
+  _internal_set_querystatusv3thumbnail(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.queryStatusV3Thumbnail)
+}
+
+// optional .proto.WebFeatures.Flag liveLocations = 7;
+inline bool WebFeatures::_internal_has_livelocations() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_livelocations() const {
+  return _internal_has_livelocations();
+}
+inline void WebFeatures::clear_livelocations() {
+  _impl_.livelocations_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocations() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocations_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::livelocations() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocations)
+  return _internal_livelocations();
+}
+inline void WebFeatures::_internal_set_livelocations(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.livelocations_ = value;
+}
+inline void WebFeatures::set_livelocations(::proto::WebFeatures_Flag value) {
+  _internal_set_livelocations(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocations)
+}
+
+// optional .proto.WebFeatures.Flag queryVname = 8;
+inline bool WebFeatures::_internal_has_queryvname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_queryvname() const {
+  return _internal_has_queryvname();
+}
+inline void WebFeatures::clear_queryvname() {
+  _impl_.queryvname_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_queryvname() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.queryvname_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::queryvname() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.queryVname)
+  return _internal_queryvname();
+}
+inline void WebFeatures::_internal_set_queryvname(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.queryvname_ = value;
+}
+inline void WebFeatures::set_queryvname(::proto::WebFeatures_Flag value) {
+  _internal_set_queryvname(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.queryVname)
+}
+
+// optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
+inline bool WebFeatures::_internal_has_voipindividualincoming() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_voipindividualincoming() const {
+  return _internal_has_voipindividualincoming();
+}
+inline void WebFeatures::clear_voipindividualincoming() {
+  _impl_.voipindividualincoming_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualincoming() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualincoming_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::voipindividualincoming() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualIncoming)
+  return _internal_voipindividualincoming();
+}
+inline void WebFeatures::_internal_set_voipindividualincoming(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.voipindividualincoming_ = value;
+}
+inline void WebFeatures::set_voipindividualincoming(::proto::WebFeatures_Flag value) {
+  _internal_set_voipindividualincoming(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualIncoming)
+}
+
+// optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
+inline bool WebFeatures::_internal_has_quickrepliesquery() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_quickrepliesquery() const {
+  return _internal_has_quickrepliesquery();
+}
+inline void WebFeatures::clear_quickrepliesquery() {
+  _impl_.quickrepliesquery_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_quickrepliesquery() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.quickrepliesquery_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::quickrepliesquery() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.quickRepliesQuery)
+  return _internal_quickrepliesquery();
+}
+inline void WebFeatures::_internal_set_quickrepliesquery(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.quickrepliesquery_ = value;
+}
+inline void WebFeatures::set_quickrepliesquery(::proto::WebFeatures_Flag value) {
+  _internal_set_quickrepliesquery(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.quickRepliesQuery)
+}
+
+// optional .proto.WebFeatures.Flag payments = 11;
+inline bool WebFeatures::_internal_has_payments() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_payments() const {
+  return _internal_has_payments();
+}
+inline void WebFeatures::clear_payments() {
+  _impl_.payments_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_payments() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.payments_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::payments() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.payments)
+  return _internal_payments();
+}
+inline void WebFeatures::_internal_set_payments(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.payments_ = value;
+}
+inline void WebFeatures::set_payments(::proto::WebFeatures_Flag value) {
+  _internal_set_payments(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.payments)
+}
+
+// optional .proto.WebFeatures.Flag stickerPackQuery = 12;
+inline bool WebFeatures::_internal_has_stickerpackquery() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_stickerpackquery() const {
+  return _internal_has_stickerpackquery();
+}
+inline void WebFeatures::clear_stickerpackquery() {
+  _impl_.stickerpackquery_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_stickerpackquery() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.stickerpackquery_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::stickerpackquery() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.stickerPackQuery)
+  return _internal_stickerpackquery();
+}
+inline void WebFeatures::_internal_set_stickerpackquery(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.stickerpackquery_ = value;
+}
+inline void WebFeatures::set_stickerpackquery(::proto::WebFeatures_Flag value) {
+  _internal_set_stickerpackquery(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.stickerPackQuery)
+}
+
+// optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
+inline bool WebFeatures::_internal_has_livelocationsfinal() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_livelocationsfinal() const {
+  return _internal_has_livelocationsfinal();
+}
+inline void WebFeatures::clear_livelocationsfinal() {
+  _impl_.livelocationsfinal_ = 0;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocationsfinal() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocationsfinal_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::livelocationsfinal() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocationsFinal)
+  return _internal_livelocationsfinal();
+}
+inline void WebFeatures::_internal_set_livelocationsfinal(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.livelocationsfinal_ = value;
+}
+inline void WebFeatures::set_livelocationsfinal(::proto::WebFeatures_Flag value) {
+  _internal_set_livelocationsfinal(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocationsFinal)
+}
+
+// optional .proto.WebFeatures.Flag labelsEdit = 14;
+inline bool WebFeatures::_internal_has_labelsedit() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_labelsedit() const {
+  return _internal_has_labelsedit();
+}
+inline void WebFeatures::clear_labelsedit() {
+  _impl_.labelsedit_ = 0;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsedit() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsedit_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::labelsedit() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsEdit)
+  return _internal_labelsedit();
+}
+inline void WebFeatures::_internal_set_labelsedit(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.labelsedit_ = value;
+}
+inline void WebFeatures::set_labelsedit(::proto::WebFeatures_Flag value) {
+  _internal_set_labelsedit(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsEdit)
+}
+
+// optional .proto.WebFeatures.Flag mediaUpload = 15;
+inline bool WebFeatures::_internal_has_mediaupload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_mediaupload() const {
+  return _internal_has_mediaupload();
+}
+inline void WebFeatures::clear_mediaupload() {
+  _impl_.mediaupload_ = 0;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediaupload() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediaupload_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::mediaupload() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUpload)
+  return _internal_mediaupload();
+}
+inline void WebFeatures::_internal_set_mediaupload(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.mediaupload_ = value;
+}
+inline void WebFeatures::set_mediaupload(::proto::WebFeatures_Flag value) {
+  _internal_set_mediaupload(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUpload)
+}
+
+// optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
+inline bool WebFeatures::_internal_has_mediauploadrichquickreplies() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_mediauploadrichquickreplies() const {
+  return _internal_has_mediauploadrichquickreplies();
+}
+inline void WebFeatures::clear_mediauploadrichquickreplies() {
+  _impl_.mediauploadrichquickreplies_ = 0;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediauploadrichquickreplies() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediauploadrichquickreplies_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::mediauploadrichquickreplies() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUploadRichQuickReplies)
+  return _internal_mediauploadrichquickreplies();
+}
+inline void WebFeatures::_internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.mediauploadrichquickreplies_ = value;
+}
+inline void WebFeatures::set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) {
+  _internal_set_mediauploadrichquickreplies(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUploadRichQuickReplies)
+}
+
+// optional .proto.WebFeatures.Flag vnameV2 = 19;
+inline bool WebFeatures::_internal_has_vnamev2() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_vnamev2() const {
+  return _internal_has_vnamev2();
+}
+inline void WebFeatures::clear_vnamev2() {
+  _impl_.vnamev2_ = 0;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_vnamev2() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.vnamev2_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::vnamev2() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.vnameV2)
+  return _internal_vnamev2();
+}
+inline void WebFeatures::_internal_set_vnamev2(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.vnamev2_ = value;
+}
+inline void WebFeatures::set_vnamev2(::proto::WebFeatures_Flag value) {
+  _internal_set_vnamev2(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.vnameV2)
+}
+
+// optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
+inline bool WebFeatures::_internal_has_videoplaybackurl() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_videoplaybackurl() const {
+  return _internal_has_videoplaybackurl();
+}
+inline void WebFeatures::clear_videoplaybackurl() {
+  _impl_.videoplaybackurl_ = 0;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_videoplaybackurl() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.videoplaybackurl_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::videoplaybackurl() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.videoPlaybackUrl)
+  return _internal_videoplaybackurl();
+}
+inline void WebFeatures::_internal_set_videoplaybackurl(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.videoplaybackurl_ = value;
+}
+inline void WebFeatures::set_videoplaybackurl(::proto::WebFeatures_Flag value) {
+  _internal_set_videoplaybackurl(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.videoPlaybackUrl)
+}
+
+// optional .proto.WebFeatures.Flag statusRanking = 21;
+inline bool WebFeatures::_internal_has_statusranking() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_statusranking() const {
+  return _internal_has_statusranking();
+}
+inline void WebFeatures::clear_statusranking() {
+  _impl_.statusranking_ = 0;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_statusranking() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.statusranking_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::statusranking() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.statusRanking)
+  return _internal_statusranking();
+}
+inline void WebFeatures::_internal_set_statusranking(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.statusranking_ = value;
+}
+inline void WebFeatures::set_statusranking(::proto::WebFeatures_Flag value) {
+  _internal_set_statusranking(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.statusRanking)
+}
+
+// optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
+inline bool WebFeatures::_internal_has_voipindividualvideo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_voipindividualvideo() const {
+  return _internal_has_voipindividualvideo();
+}
+inline void WebFeatures::clear_voipindividualvideo() {
+  _impl_.voipindividualvideo_ = 0;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualvideo() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualvideo_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::voipindividualvideo() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualVideo)
+  return _internal_voipindividualvideo();
+}
+inline void WebFeatures::_internal_set_voipindividualvideo(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.voipindividualvideo_ = value;
+}
+inline void WebFeatures::set_voipindividualvideo(::proto::WebFeatures_Flag value) {
+  _internal_set_voipindividualvideo(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualVideo)
+}
+
+// optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
+inline bool WebFeatures::_internal_has_thirdpartystickers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_thirdpartystickers() const {
+  return _internal_has_thirdpartystickers();
+}
+inline void WebFeatures::clear_thirdpartystickers() {
+  _impl_.thirdpartystickers_ = 0;
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_thirdpartystickers() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.thirdpartystickers_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::thirdpartystickers() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.thirdPartyStickers)
+  return _internal_thirdpartystickers();
+}
+inline void WebFeatures::_internal_set_thirdpartystickers(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.thirdpartystickers_ = value;
+}
+inline void WebFeatures::set_thirdpartystickers(::proto::WebFeatures_Flag value) {
+  _internal_set_thirdpartystickers(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.thirdPartyStickers)
+}
+
+// optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
+inline bool WebFeatures::_internal_has_frequentlyforwardedsetting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_frequentlyforwardedsetting() const {
+  return _internal_has_frequentlyforwardedsetting();
+}
+inline void WebFeatures::clear_frequentlyforwardedsetting() {
+  _impl_.frequentlyforwardedsetting_ = 0;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_frequentlyforwardedsetting() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.frequentlyforwardedsetting_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::frequentlyforwardedsetting() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.frequentlyForwardedSetting)
+  return _internal_frequentlyforwardedsetting();
+}
+inline void WebFeatures::_internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.frequentlyforwardedsetting_ = value;
+}
+inline void WebFeatures::set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) {
+  _internal_set_frequentlyforwardedsetting(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.frequentlyForwardedSetting)
+}
+
+// optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
+inline bool WebFeatures::_internal_has_groupsv4joinpermission() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_groupsv4joinpermission() const {
+  return _internal_has_groupsv4joinpermission();
+}
+inline void WebFeatures::clear_groupsv4joinpermission() {
+  _impl_.groupsv4joinpermission_ = 0;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv4joinpermission() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv4joinpermission_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::groupsv4joinpermission() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV4JoinPermission)
+  return _internal_groupsv4joinpermission();
+}
+inline void WebFeatures::_internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.groupsv4joinpermission_ = value;
+}
+inline void WebFeatures::set_groupsv4joinpermission(::proto::WebFeatures_Flag value) {
+  _internal_set_groupsv4joinpermission(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV4JoinPermission)
+}
+
+// optional .proto.WebFeatures.Flag recentStickers = 26;
+inline bool WebFeatures::_internal_has_recentstickers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_recentstickers() const {
+  return _internal_has_recentstickers();
+}
+inline void WebFeatures::clear_recentstickers() {
+  _impl_.recentstickers_ = 0;
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickers() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickers_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::recentstickers() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickers)
+  return _internal_recentstickers();
+}
+inline void WebFeatures::_internal_set_recentstickers(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00800000u;
+  _impl_.recentstickers_ = value;
+}
+inline void WebFeatures::set_recentstickers(::proto::WebFeatures_Flag value) {
+  _internal_set_recentstickers(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickers)
+}
+
+// optional .proto.WebFeatures.Flag catalog = 27;
+inline bool WebFeatures::_internal_has_catalog() const {
+  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_catalog() const {
+  return _internal_has_catalog();
+}
+inline void WebFeatures::clear_catalog() {
+  _impl_.catalog_ = 0;
+  _impl_._has_bits_[0] &= ~0x01000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_catalog() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.catalog_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::catalog() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.catalog)
+  return _internal_catalog();
+}
+inline void WebFeatures::_internal_set_catalog(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x01000000u;
+  _impl_.catalog_ = value;
+}
+inline void WebFeatures::set_catalog(::proto::WebFeatures_Flag value) {
+  _internal_set_catalog(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.catalog)
+}
+
+// optional .proto.WebFeatures.Flag starredStickers = 28;
+inline bool WebFeatures::_internal_has_starredstickers() const {
+  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_starredstickers() const {
+  return _internal_has_starredstickers();
+}
+inline void WebFeatures::clear_starredstickers() {
+  _impl_.starredstickers_ = 0;
+  _impl_._has_bits_[0] &= ~0x02000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_starredstickers() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.starredstickers_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::starredstickers() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.starredStickers)
+  return _internal_starredstickers();
+}
+inline void WebFeatures::_internal_set_starredstickers(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x02000000u;
+  _impl_.starredstickers_ = value;
+}
+inline void WebFeatures::set_starredstickers(::proto::WebFeatures_Flag value) {
+  _internal_set_starredstickers(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.starredStickers)
+}
+
+// optional .proto.WebFeatures.Flag voipGroupCall = 29;
+inline bool WebFeatures::_internal_has_voipgroupcall() const {
+  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_voipgroupcall() const {
+  return _internal_has_voipgroupcall();
+}
+inline void WebFeatures::clear_voipgroupcall() {
+  _impl_.voipgroupcall_ = 0;
+  _impl_._has_bits_[0] &= ~0x04000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipgroupcall() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipgroupcall_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::voipgroupcall() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipGroupCall)
+  return _internal_voipgroupcall();
+}
+inline void WebFeatures::_internal_set_voipgroupcall(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x04000000u;
+  _impl_.voipgroupcall_ = value;
+}
+inline void WebFeatures::set_voipgroupcall(::proto::WebFeatures_Flag value) {
+  _internal_set_voipgroupcall(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipGroupCall)
+}
+
+// optional .proto.WebFeatures.Flag templateMessage = 30;
+inline bool WebFeatures::_internal_has_templatemessage() const {
+  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_templatemessage() const {
+  return _internal_has_templatemessage();
+}
+inline void WebFeatures::clear_templatemessage() {
+  _impl_.templatemessage_ = 0;
+  _impl_._has_bits_[0] &= ~0x08000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessage() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessage_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::templatemessage() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessage)
+  return _internal_templatemessage();
+}
+inline void WebFeatures::_internal_set_templatemessage(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x08000000u;
+  _impl_.templatemessage_ = value;
+}
+inline void WebFeatures::set_templatemessage(::proto::WebFeatures_Flag value) {
+  _internal_set_templatemessage(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessage)
+}
+
+// optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
+inline bool WebFeatures::_internal_has_templatemessageinteractivity() const {
+  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_templatemessageinteractivity() const {
+  return _internal_has_templatemessageinteractivity();
+}
+inline void WebFeatures::clear_templatemessageinteractivity() {
+  _impl_.templatemessageinteractivity_ = 0;
+  _impl_._has_bits_[0] &= ~0x10000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessageinteractivity() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessageinteractivity_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::templatemessageinteractivity() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessageInteractivity)
+  return _internal_templatemessageinteractivity();
+}
+inline void WebFeatures::_internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x10000000u;
+  _impl_.templatemessageinteractivity_ = value;
+}
+inline void WebFeatures::set_templatemessageinteractivity(::proto::WebFeatures_Flag value) {
+  _internal_set_templatemessageinteractivity(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessageInteractivity)
+}
+
+// optional .proto.WebFeatures.Flag ephemeralMessages = 32;
+inline bool WebFeatures::_internal_has_ephemeralmessages() const {
+  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_ephemeralmessages() const {
+  return _internal_has_ephemeralmessages();
+}
+inline void WebFeatures::clear_ephemeralmessages() {
+  _impl_.ephemeralmessages_ = 0;
+  _impl_._has_bits_[0] &= ~0x20000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralmessages() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralmessages_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::ephemeralmessages() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralMessages)
+  return _internal_ephemeralmessages();
+}
+inline void WebFeatures::_internal_set_ephemeralmessages(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x20000000u;
+  _impl_.ephemeralmessages_ = value;
+}
+inline void WebFeatures::set_ephemeralmessages(::proto::WebFeatures_Flag value) {
+  _internal_set_ephemeralmessages(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralMessages)
+}
+
+// optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
+inline bool WebFeatures::_internal_has_e2enotificationsync() const {
+  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_e2enotificationsync() const {
+  return _internal_has_e2enotificationsync();
+}
+inline void WebFeatures::clear_e2enotificationsync() {
+  _impl_.e2enotificationsync_ = 0;
+  _impl_._has_bits_[0] &= ~0x40000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_e2enotificationsync() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.e2enotificationsync_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::e2enotificationsync() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.e2ENotificationSync)
+  return _internal_e2enotificationsync();
+}
+inline void WebFeatures::_internal_set_e2enotificationsync(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x40000000u;
+  _impl_.e2enotificationsync_ = value;
+}
+inline void WebFeatures::set_e2enotificationsync(::proto::WebFeatures_Flag value) {
+  _internal_set_e2enotificationsync(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.e2ENotificationSync)
+}
+
+// optional .proto.WebFeatures.Flag recentStickersV2 = 34;
+inline bool WebFeatures::_internal_has_recentstickersv2() const {
+  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_recentstickersv2() const {
+  return _internal_has_recentstickersv2();
+}
+inline void WebFeatures::clear_recentstickersv2() {
+  _impl_.recentstickersv2_ = 0;
+  _impl_._has_bits_[0] &= ~0x80000000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv2() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv2_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv2() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV2)
+  return _internal_recentstickersv2();
+}
+inline void WebFeatures::_internal_set_recentstickersv2(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[0] |= 0x80000000u;
+  _impl_.recentstickersv2_ = value;
+}
+inline void WebFeatures::set_recentstickersv2(::proto::WebFeatures_Flag value) {
+  _internal_set_recentstickersv2(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV2)
+}
+
+// optional .proto.WebFeatures.Flag recentStickersV3 = 36;
+inline bool WebFeatures::_internal_has_recentstickersv3() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_recentstickersv3() const {
+  return _internal_has_recentstickersv3();
+}
+inline void WebFeatures::clear_recentstickersv3() {
+  _impl_.recentstickersv3_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000001u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv3() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv3_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv3() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV3)
+  return _internal_recentstickersv3();
+}
+inline void WebFeatures::_internal_set_recentstickersv3(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000001u;
+  _impl_.recentstickersv3_ = value;
+}
+inline void WebFeatures::set_recentstickersv3(::proto::WebFeatures_Flag value) {
+  _internal_set_recentstickersv3(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV3)
+}
+
+// optional .proto.WebFeatures.Flag userNotice = 37;
+inline bool WebFeatures::_internal_has_usernotice() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_usernotice() const {
+  return _internal_has_usernotice();
+}
+inline void WebFeatures::clear_usernotice() {
+  _impl_.usernotice_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000002u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_usernotice() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.usernotice_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::usernotice() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.userNotice)
+  return _internal_usernotice();
+}
+inline void WebFeatures::_internal_set_usernotice(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000002u;
+  _impl_.usernotice_ = value;
+}
+inline void WebFeatures::set_usernotice(::proto::WebFeatures_Flag value) {
+  _internal_set_usernotice(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.userNotice)
+}
+
+// optional .proto.WebFeatures.Flag support = 39;
+inline bool WebFeatures::_internal_has_support() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_support() const {
+  return _internal_has_support();
+}
+inline void WebFeatures::clear_support() {
+  _impl_.support_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000004u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_support() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.support_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::support() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.support)
+  return _internal_support();
+}
+inline void WebFeatures::_internal_set_support(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000004u;
+  _impl_.support_ = value;
+}
+inline void WebFeatures::set_support(::proto::WebFeatures_Flag value) {
+  _internal_set_support(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.support)
+}
+
+// optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
+inline bool WebFeatures::_internal_has_groupuiicleanup() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_groupuiicleanup() const {
+  return _internal_has_groupuiicleanup();
+}
+inline void WebFeatures::clear_groupuiicleanup() {
+  _impl_.groupuiicleanup_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000008u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupuiicleanup() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupuiicleanup_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::groupuiicleanup() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupUiiCleanup)
+  return _internal_groupuiicleanup();
+}
+inline void WebFeatures::_internal_set_groupuiicleanup(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000008u;
+  _impl_.groupuiicleanup_ = value;
+}
+inline void WebFeatures::set_groupuiicleanup(::proto::WebFeatures_Flag value) {
+  _internal_set_groupuiicleanup(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupUiiCleanup)
+}
+
+// optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
+inline bool WebFeatures::_internal_has_groupdogfoodinginternalonly() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_groupdogfoodinginternalonly() const {
+  return _internal_has_groupdogfoodinginternalonly();
+}
+inline void WebFeatures::clear_groupdogfoodinginternalonly() {
+  _impl_.groupdogfoodinginternalonly_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000010u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupdogfoodinginternalonly() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupdogfoodinginternalonly_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::groupdogfoodinginternalonly() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupDogfoodingInternalOnly)
+  return _internal_groupdogfoodinginternalonly();
+}
+inline void WebFeatures::_internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000010u;
+  _impl_.groupdogfoodinginternalonly_ = value;
+}
+inline void WebFeatures::set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) {
+  _internal_set_groupdogfoodinginternalonly(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupDogfoodingInternalOnly)
+}
+
+// optional .proto.WebFeatures.Flag settingsSync = 42;
+inline bool WebFeatures::_internal_has_settingssync() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_settingssync() const {
+  return _internal_has_settingssync();
+}
+inline void WebFeatures::clear_settingssync() {
+  _impl_.settingssync_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000020u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_settingssync() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.settingssync_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::settingssync() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.settingsSync)
+  return _internal_settingssync();
+}
+inline void WebFeatures::_internal_set_settingssync(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000020u;
+  _impl_.settingssync_ = value;
+}
+inline void WebFeatures::set_settingssync(::proto::WebFeatures_Flag value) {
+  _internal_set_settingssync(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.settingsSync)
+}
+
+// optional .proto.WebFeatures.Flag archiveV2 = 43;
+inline bool WebFeatures::_internal_has_archivev2() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_archivev2() const {
+  return _internal_has_archivev2();
+}
+inline void WebFeatures::clear_archivev2() {
+  _impl_.archivev2_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000040u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_archivev2() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.archivev2_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::archivev2() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.archiveV2)
+  return _internal_archivev2();
+}
+inline void WebFeatures::_internal_set_archivev2(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000040u;
+  _impl_.archivev2_ = value;
+}
+inline void WebFeatures::set_archivev2(::proto::WebFeatures_Flag value) {
+  _internal_set_archivev2(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.archiveV2)
+}
+
+// optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
+inline bool WebFeatures::_internal_has_ephemeralallowgroupmembers() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_ephemeralallowgroupmembers() const {
+  return _internal_has_ephemeralallowgroupmembers();
+}
+inline void WebFeatures::clear_ephemeralallowgroupmembers() {
+  _impl_.ephemeralallowgroupmembers_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000080u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralallowgroupmembers() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralallowgroupmembers_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::ephemeralallowgroupmembers() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralAllowGroupMembers)
+  return _internal_ephemeralallowgroupmembers();
+}
+inline void WebFeatures::_internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000080u;
+  _impl_.ephemeralallowgroupmembers_ = value;
+}
+inline void WebFeatures::set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) {
+  _internal_set_ephemeralallowgroupmembers(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralAllowGroupMembers)
+}
+
+// optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
+inline bool WebFeatures::_internal_has_ephemeral24hduration() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_ephemeral24hduration() const {
+  return _internal_has_ephemeral24hduration();
+}
+inline void WebFeatures::clear_ephemeral24hduration() {
+  _impl_.ephemeral24hduration_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000100u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeral24hduration() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeral24hduration_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::ephemeral24hduration() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeral24HDuration)
+  return _internal_ephemeral24hduration();
+}
+inline void WebFeatures::_internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000100u;
+  _impl_.ephemeral24hduration_ = value;
+}
+inline void WebFeatures::set_ephemeral24hduration(::proto::WebFeatures_Flag value) {
+  _internal_set_ephemeral24hduration(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeral24HDuration)
+}
+
+// optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
+inline bool WebFeatures::_internal_has_mdforceupgrade() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_mdforceupgrade() const {
+  return _internal_has_mdforceupgrade();
+}
+inline void WebFeatures::clear_mdforceupgrade() {
+  _impl_.mdforceupgrade_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000200u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_mdforceupgrade() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mdforceupgrade_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::mdforceupgrade() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.mdForceUpgrade)
+  return _internal_mdforceupgrade();
+}
+inline void WebFeatures::_internal_set_mdforceupgrade(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000200u;
+  _impl_.mdforceupgrade_ = value;
+}
+inline void WebFeatures::set_mdforceupgrade(::proto::WebFeatures_Flag value) {
+  _internal_set_mdforceupgrade(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.mdForceUpgrade)
+}
+
+// optional .proto.WebFeatures.Flag disappearingMode = 47;
+inline bool WebFeatures::_internal_has_disappearingmode() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_disappearingmode() const {
+  return _internal_has_disappearingmode();
+}
+inline void WebFeatures::clear_disappearingmode() {
+  _impl_.disappearingmode_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000400u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_disappearingmode() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.disappearingmode_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::disappearingmode() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.disappearingMode)
+  return _internal_disappearingmode();
+}
+inline void WebFeatures::_internal_set_disappearingmode(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000400u;
+  _impl_.disappearingmode_ = value;
+}
+inline void WebFeatures::set_disappearingmode(::proto::WebFeatures_Flag value) {
+  _internal_set_disappearingmode(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.disappearingMode)
+}
+
+// optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
+inline bool WebFeatures::_internal_has_externalmdoptinavailable() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_externalmdoptinavailable() const {
+  return _internal_has_externalmdoptinavailable();
+}
+inline void WebFeatures::clear_externalmdoptinavailable() {
+  _impl_.externalmdoptinavailable_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000800u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_externalmdoptinavailable() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.externalmdoptinavailable_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::externalmdoptinavailable() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.externalMdOptInAvailable)
+  return _internal_externalmdoptinavailable();
+}
+inline void WebFeatures::_internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000800u;
+  _impl_.externalmdoptinavailable_ = value;
+}
+inline void WebFeatures::set_externalmdoptinavailable(::proto::WebFeatures_Flag value) {
+  _internal_set_externalmdoptinavailable(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.externalMdOptInAvailable)
+}
+
+// optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
+inline bool WebFeatures::_internal_has_nodeletemessagetimelimit() const {
+  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
+  return value;
+}
+inline bool WebFeatures::has_nodeletemessagetimelimit() const {
+  return _internal_has_nodeletemessagetimelimit();
+}
+inline void WebFeatures::clear_nodeletemessagetimelimit() {
+  _impl_.nodeletemessagetimelimit_ = 0;
+  _impl_._has_bits_[1] &= ~0x00001000u;
+}
+inline ::proto::WebFeatures_Flag WebFeatures::_internal_nodeletemessagetimelimit() const {
+  return static_cast< ::proto::WebFeatures_Flag >(_impl_.nodeletemessagetimelimit_);
+}
+inline ::proto::WebFeatures_Flag WebFeatures::nodeletemessagetimelimit() const {
+  // @@protoc_insertion_point(field_get:proto.WebFeatures.noDeleteMessageTimeLimit)
+  return _internal_nodeletemessagetimelimit();
+}
+inline void WebFeatures::_internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) {
+  assert(::proto::WebFeatures_Flag_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00001000u;
+  _impl_.nodeletemessagetimelimit_ = value;
+}
+inline void WebFeatures::set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) {
+  _internal_set_nodeletemessagetimelimit(value);
+  // @@protoc_insertion_point(field_set:proto.WebFeatures.noDeleteMessageTimeLimit)
+}
+
+// -------------------------------------------------------------------
+
+// WebMessageInfo
+
+// required .proto.MessageKey key = 1;
+inline bool WebMessageInfo::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_key() const {
+  return _internal_has_key();
+}
+inline void WebMessageInfo::clear_key() {
+  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const ::proto::MessageKey& WebMessageInfo::_internal_key() const {
+  const ::proto::MessageKey* p = _impl_.key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
+      ::proto::_MessageKey_default_instance_);
+}
+inline const ::proto::MessageKey& WebMessageInfo::key() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.key)
+  return _internal_key();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_key(
+    ::proto::MessageKey* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
+  }
+  _impl_.key_ = key;
+  if (key) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.key)
+}
+inline ::proto::MessageKey* WebMessageInfo::release_key() {
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MessageKey* WebMessageInfo::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.key)
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  ::proto::MessageKey* temp = _impl_.key_;
+  _impl_.key_ = nullptr;
+  return temp;
+}
+inline ::proto::MessageKey* WebMessageInfo::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  if (_impl_.key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
+    _impl_.key_ = p;
+  }
+  return _impl_.key_;
+}
+inline ::proto::MessageKey* WebMessageInfo::mutable_key() {
+  ::proto::MessageKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.key)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_key(::proto::MessageKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.key)
+}
+
+// optional .proto.Message message = 2;
+inline bool WebMessageInfo::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_message() const {
+  return _internal_has_message();
+}
+inline void WebMessageInfo::clear_message() {
+  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const ::proto::Message& WebMessageInfo::_internal_message() const {
+  const ::proto::Message* p = _impl_.message_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
+      ::proto::_Message_default_instance_);
+}
+inline const ::proto::Message& WebMessageInfo::message() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.message)
+  return _internal_message();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_message(
+    ::proto::Message* message) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
+  }
+  _impl_.message_ = message;
+  if (message) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.message)
+}
+inline ::proto::Message* WebMessageInfo::release_message() {
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message* WebMessageInfo::unsafe_arena_release_message() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.message)
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  ::proto::Message* temp = _impl_.message_;
+  _impl_.message_ = nullptr;
+  return temp;
+}
+inline ::proto::Message* WebMessageInfo::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  if (_impl_.message_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
+    _impl_.message_ = p;
+  }
+  return _impl_.message_;
+}
+inline ::proto::Message* WebMessageInfo::mutable_message() {
+  ::proto::Message* _msg = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.message)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_message(::proto::Message* message) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.message_;
+  }
+  if (message) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
+    if (message_arena != submessage_arena) {
+      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, message, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.message_ = message;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.message)
+}
+
+// optional uint64 messageTimestamp = 3;
+inline bool WebMessageInfo::_internal_has_messagetimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_messagetimestamp() const {
+  return _internal_has_messagetimestamp();
+}
+inline void WebMessageInfo::clear_messagetimestamp() {
+  _impl_.messagetimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline uint64_t WebMessageInfo::_internal_messagetimestamp() const {
+  return _impl_.messagetimestamp_;
+}
+inline uint64_t WebMessageInfo::messagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageTimestamp)
+  return _internal_messagetimestamp();
+}
+inline void WebMessageInfo::_internal_set_messagetimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.messagetimestamp_ = value;
+}
+inline void WebMessageInfo::set_messagetimestamp(uint64_t value) {
+  _internal_set_messagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageTimestamp)
+}
+
+// optional .proto.WebMessageInfo.Status status = 4;
+inline bool WebMessageInfo::_internal_has_status() const {
+  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_status() const {
+  return _internal_has_status();
+}
+inline void WebMessageInfo::clear_status() {
+  _impl_.status_ = 0;
+  _impl_._has_bits_[0] &= ~0x00200000u;
+}
+inline ::proto::WebMessageInfo_Status WebMessageInfo::_internal_status() const {
+  return static_cast< ::proto::WebMessageInfo_Status >(_impl_.status_);
+}
+inline ::proto::WebMessageInfo_Status WebMessageInfo::status() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.status)
+  return _internal_status();
+}
+inline void WebMessageInfo::_internal_set_status(::proto::WebMessageInfo_Status value) {
+  assert(::proto::WebMessageInfo_Status_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00200000u;
+  _impl_.status_ = value;
+}
+inline void WebMessageInfo::set_status(::proto::WebMessageInfo_Status value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.status)
+}
+
+// optional string participant = 5;
+inline bool WebMessageInfo::_internal_has_participant() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_participant() const {
+  return _internal_has_participant();
+}
+inline void WebMessageInfo::clear_participant() {
+  _impl_.participant_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WebMessageInfo::participant() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.participant)
+  return _internal_participant();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.participant)
+}
+inline std::string* WebMessageInfo::mutable_participant() {
+  std::string* _s = _internal_mutable_participant();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.participant)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_participant() const {
+  return _impl_.participant_.Get();
+}
+inline void WebMessageInfo::_internal_set_participant(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.participant_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_participant() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.participant_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_participant() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.participant)
+  if (!_internal_has_participant()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.participant_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_participant(std::string* participant) {
+  if (participant != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.participant_.IsDefault()) {
+    _impl_.participant_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.participant)
+}
+
+// optional uint64 messageC2STimestamp = 6;
+inline bool WebMessageInfo::_internal_has_messagec2stimestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_messagec2stimestamp() const {
+  return _internal_has_messagec2stimestamp();
+}
+inline void WebMessageInfo::clear_messagec2stimestamp() {
+  _impl_.messagec2stimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00100000u;
+}
+inline uint64_t WebMessageInfo::_internal_messagec2stimestamp() const {
+  return _impl_.messagec2stimestamp_;
+}
+inline uint64_t WebMessageInfo::messagec2stimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageC2STimestamp)
+  return _internal_messagec2stimestamp();
+}
+inline void WebMessageInfo::_internal_set_messagec2stimestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00100000u;
+  _impl_.messagec2stimestamp_ = value;
+}
+inline void WebMessageInfo::set_messagec2stimestamp(uint64_t value) {
+  _internal_set_messagec2stimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageC2STimestamp)
+}
+
+// optional bool ignore = 16;
+inline bool WebMessageInfo::_internal_has_ignore() const {
+  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_ignore() const {
+  return _internal_has_ignore();
+}
+inline void WebMessageInfo::clear_ignore() {
+  _impl_.ignore_ = false;
+  _impl_._has_bits_[0] &= ~0x00400000u;
+}
+inline bool WebMessageInfo::_internal_ignore() const {
+  return _impl_.ignore_;
+}
+inline bool WebMessageInfo::ignore() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ignore)
+  return _internal_ignore();
+}
+inline void WebMessageInfo::_internal_set_ignore(bool value) {
+  _impl_._has_bits_[0] |= 0x00400000u;
+  _impl_.ignore_ = value;
+}
+inline void WebMessageInfo::set_ignore(bool value) {
+  _internal_set_ignore(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ignore)
+}
+
+// optional bool starred = 17;
+inline bool WebMessageInfo::_internal_has_starred() const {
+  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_starred() const {
+  return _internal_has_starred();
+}
+inline void WebMessageInfo::clear_starred() {
+  _impl_.starred_ = false;
+  _impl_._has_bits_[0] &= ~0x00800000u;
+}
+inline bool WebMessageInfo::_internal_starred() const {
+  return _impl_.starred_;
+}
+inline bool WebMessageInfo::starred() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.starred)
+  return _internal_starred();
+}
+inline void WebMessageInfo::_internal_set_starred(bool value) {
+  _impl_._has_bits_[0] |= 0x00800000u;
+  _impl_.starred_ = value;
+}
+inline void WebMessageInfo::set_starred(bool value) {
+  _internal_set_starred(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.starred)
+}
+
+// optional bool broadcast = 18;
+inline bool WebMessageInfo::_internal_has_broadcast() const {
+  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_broadcast() const {
+  return _internal_has_broadcast();
+}
+inline void WebMessageInfo::clear_broadcast() {
+  _impl_.broadcast_ = false;
+  _impl_._has_bits_[0] &= ~0x01000000u;
+}
+inline bool WebMessageInfo::_internal_broadcast() const {
+  return _impl_.broadcast_;
+}
+inline bool WebMessageInfo::broadcast() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.broadcast)
+  return _internal_broadcast();
+}
+inline void WebMessageInfo::_internal_set_broadcast(bool value) {
+  _impl_._has_bits_[0] |= 0x01000000u;
+  _impl_.broadcast_ = value;
+}
+inline void WebMessageInfo::set_broadcast(bool value) {
+  _internal_set_broadcast(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.broadcast)
+}
+
+// optional string pushName = 19;
+inline bool WebMessageInfo::_internal_has_pushname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_pushname() const {
+  return _internal_has_pushname();
+}
+inline void WebMessageInfo::clear_pushname() {
+  _impl_.pushname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& WebMessageInfo::pushname() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pushName)
+  return _internal_pushname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_pushname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.pushName)
+}
+inline std::string* WebMessageInfo::mutable_pushname() {
+  std::string* _s = _internal_mutable_pushname();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pushName)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_pushname() const {
+  return _impl_.pushname_.Get();
+}
+inline void WebMessageInfo::_internal_set_pushname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.pushname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_pushname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.pushname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_pushname() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pushName)
+  if (!_internal_has_pushname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.pushname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_pushname(std::string* pushname) {
+  if (pushname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.pushname_.IsDefault()) {
+    _impl_.pushname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pushName)
+}
+
+// optional bytes mediaCiphertextSha256 = 20;
+inline bool WebMessageInfo::_internal_has_mediaciphertextsha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_mediaciphertextsha256() const {
+  return _internal_has_mediaciphertextsha256();
+}
+inline void WebMessageInfo::clear_mediaciphertextsha256() {
+  _impl_.mediaciphertextsha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& WebMessageInfo::mediaciphertextsha256() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaCiphertextSha256)
+  return _internal_mediaciphertextsha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.mediaciphertextsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.mediaCiphertextSha256)
+}
+inline std::string* WebMessageInfo::mutable_mediaciphertextsha256() {
+  std::string* _s = _internal_mutable_mediaciphertextsha256();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaCiphertextSha256)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_mediaciphertextsha256() const {
+  return _impl_.mediaciphertextsha256_.Get();
+}
+inline void WebMessageInfo::_internal_set_mediaciphertextsha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.mediaciphertextsha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_mediaciphertextsha256() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.mediaciphertextsha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_mediaciphertextsha256() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaCiphertextSha256)
+  if (!_internal_has_mediaciphertextsha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.mediaciphertextsha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediaciphertextsha256_.IsDefault()) {
+    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256) {
+  if (mediaciphertextsha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.mediaciphertextsha256_.SetAllocated(mediaciphertextsha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mediaciphertextsha256_.IsDefault()) {
+    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaCiphertextSha256)
+}
+
+// optional bool multicast = 21;
+inline bool WebMessageInfo::_internal_has_multicast() const {
+  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_multicast() const {
+  return _internal_has_multicast();
+}
+inline void WebMessageInfo::clear_multicast() {
+  _impl_.multicast_ = false;
+  _impl_._has_bits_[0] &= ~0x02000000u;
+}
+inline bool WebMessageInfo::_internal_multicast() const {
+  return _impl_.multicast_;
+}
+inline bool WebMessageInfo::multicast() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.multicast)
+  return _internal_multicast();
+}
+inline void WebMessageInfo::_internal_set_multicast(bool value) {
+  _impl_._has_bits_[0] |= 0x02000000u;
+  _impl_.multicast_ = value;
+}
+inline void WebMessageInfo::set_multicast(bool value) {
+  _internal_set_multicast(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.multicast)
+}
+
+// optional bool urlText = 22;
+inline bool WebMessageInfo::_internal_has_urltext() const {
+  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_urltext() const {
+  return _internal_has_urltext();
+}
+inline void WebMessageInfo::clear_urltext() {
+  _impl_.urltext_ = false;
+  _impl_._has_bits_[0] &= ~0x08000000u;
+}
+inline bool WebMessageInfo::_internal_urltext() const {
+  return _impl_.urltext_;
+}
+inline bool WebMessageInfo::urltext() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlText)
+  return _internal_urltext();
+}
+inline void WebMessageInfo::_internal_set_urltext(bool value) {
+  _impl_._has_bits_[0] |= 0x08000000u;
+  _impl_.urltext_ = value;
+}
+inline void WebMessageInfo::set_urltext(bool value) {
+  _internal_set_urltext(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlText)
+}
+
+// optional bool urlNumber = 23;
+inline bool WebMessageInfo::_internal_has_urlnumber() const {
+  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_urlnumber() const {
+  return _internal_has_urlnumber();
+}
+inline void WebMessageInfo::clear_urlnumber() {
+  _impl_.urlnumber_ = false;
+  _impl_._has_bits_[0] &= ~0x10000000u;
+}
+inline bool WebMessageInfo::_internal_urlnumber() const {
+  return _impl_.urlnumber_;
+}
+inline bool WebMessageInfo::urlnumber() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlNumber)
+  return _internal_urlnumber();
+}
+inline void WebMessageInfo::_internal_set_urlnumber(bool value) {
+  _impl_._has_bits_[0] |= 0x10000000u;
+  _impl_.urlnumber_ = value;
+}
+inline void WebMessageInfo::set_urlnumber(bool value) {
+  _internal_set_urlnumber(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlNumber)
+}
+
+// optional .proto.WebMessageInfo.StubType messageStubType = 24;
+inline bool WebMessageInfo::_internal_has_messagestubtype() const {
+  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_messagestubtype() const {
+  return _internal_has_messagestubtype();
+}
+inline void WebMessageInfo::clear_messagestubtype() {
+  _impl_.messagestubtype_ = 0;
+  _impl_._has_bits_[0] &= ~0x04000000u;
+}
+inline ::proto::WebMessageInfo_StubType WebMessageInfo::_internal_messagestubtype() const {
+  return static_cast< ::proto::WebMessageInfo_StubType >(_impl_.messagestubtype_);
+}
+inline ::proto::WebMessageInfo_StubType WebMessageInfo::messagestubtype() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubType)
+  return _internal_messagestubtype();
+}
+inline void WebMessageInfo::_internal_set_messagestubtype(::proto::WebMessageInfo_StubType value) {
+  assert(::proto::WebMessageInfo_StubType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x04000000u;
+  _impl_.messagestubtype_ = value;
+}
+inline void WebMessageInfo::set_messagestubtype(::proto::WebMessageInfo_StubType value) {
+  _internal_set_messagestubtype(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubType)
+}
+
+// optional bool clearMedia = 25;
+inline bool WebMessageInfo::_internal_has_clearmedia() const {
+  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_clearmedia() const {
+  return _internal_has_clearmedia();
+}
+inline void WebMessageInfo::clear_clearmedia() {
+  _impl_.clearmedia_ = false;
+  _impl_._has_bits_[0] &= ~0x20000000u;
+}
+inline bool WebMessageInfo::_internal_clearmedia() const {
+  return _impl_.clearmedia_;
+}
+inline bool WebMessageInfo::clearmedia() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.clearMedia)
+  return _internal_clearmedia();
+}
+inline void WebMessageInfo::_internal_set_clearmedia(bool value) {
+  _impl_._has_bits_[0] |= 0x20000000u;
+  _impl_.clearmedia_ = value;
+}
+inline void WebMessageInfo::set_clearmedia(bool value) {
+  _internal_set_clearmedia(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.clearMedia)
+}
+
+// repeated string messageStubParameters = 26;
+inline int WebMessageInfo::_internal_messagestubparameters_size() const {
+  return _impl_.messagestubparameters_.size();
+}
+inline int WebMessageInfo::messagestubparameters_size() const {
+  return _internal_messagestubparameters_size();
+}
+inline void WebMessageInfo::clear_messagestubparameters() {
+  _impl_.messagestubparameters_.Clear();
+}
+inline std::string* WebMessageInfo::add_messagestubparameters() {
+  std::string* _s = _internal_add_messagestubparameters();
+  // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.messageStubParameters)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_messagestubparameters(int index) const {
+  return _impl_.messagestubparameters_.Get(index);
+}
+inline const std::string& WebMessageInfo::messagestubparameters(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubParameters)
+  return _internal_messagestubparameters(index);
+}
+inline std::string* WebMessageInfo::mutable_messagestubparameters(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageStubParameters)
+  return _impl_.messagestubparameters_.Mutable(index);
+}
+inline void WebMessageInfo::set_messagestubparameters(int index, const std::string& value) {
+  _impl_.messagestubparameters_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::set_messagestubparameters(int index, std::string&& value) {
+  _impl_.messagestubparameters_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::set_messagestubparameters(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.messagestubparameters_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::set_messagestubparameters(int index, const char* value, size_t size) {
+  _impl_.messagestubparameters_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.messageStubParameters)
+}
+inline std::string* WebMessageInfo::_internal_add_messagestubparameters() {
+  return _impl_.messagestubparameters_.Add();
+}
+inline void WebMessageInfo::add_messagestubparameters(const std::string& value) {
+  _impl_.messagestubparameters_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::add_messagestubparameters(std::string&& value) {
+  _impl_.messagestubparameters_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::add_messagestubparameters(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.messagestubparameters_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.messageStubParameters)
+}
+inline void WebMessageInfo::add_messagestubparameters(const char* value, size_t size) {
+  _impl_.messagestubparameters_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.messageStubParameters)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WebMessageInfo::messagestubparameters() const {
+  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.messageStubParameters)
+  return _impl_.messagestubparameters_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WebMessageInfo::mutable_messagestubparameters() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.messageStubParameters)
+  return &_impl_.messagestubparameters_;
+}
+
+// optional uint32 duration = 27;
+inline bool WebMessageInfo::_internal_has_duration() const {
+  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_duration() const {
+  return _internal_has_duration();
+}
+inline void WebMessageInfo::clear_duration() {
+  _impl_.duration_ = 0u;
+  _impl_._has_bits_[0] &= ~0x80000000u;
+}
+inline uint32_t WebMessageInfo::_internal_duration() const {
+  return _impl_.duration_;
+}
+inline uint32_t WebMessageInfo::duration() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.duration)
+  return _internal_duration();
+}
+inline void WebMessageInfo::_internal_set_duration(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x80000000u;
+  _impl_.duration_ = value;
+}
+inline void WebMessageInfo::set_duration(uint32_t value) {
+  _internal_set_duration(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.duration)
+}
+
+// repeated string labels = 28;
+inline int WebMessageInfo::_internal_labels_size() const {
+  return _impl_.labels_.size();
+}
+inline int WebMessageInfo::labels_size() const {
+  return _internal_labels_size();
+}
+inline void WebMessageInfo::clear_labels() {
+  _impl_.labels_.Clear();
+}
+inline std::string* WebMessageInfo::add_labels() {
+  std::string* _s = _internal_add_labels();
+  // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.labels)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_labels(int index) const {
+  return _impl_.labels_.Get(index);
+}
+inline const std::string& WebMessageInfo::labels(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.labels)
+  return _internal_labels(index);
+}
+inline std::string* WebMessageInfo::mutable_labels(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.labels)
+  return _impl_.labels_.Mutable(index);
+}
+inline void WebMessageInfo::set_labels(int index, const std::string& value) {
+  _impl_.labels_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::set_labels(int index, std::string&& value) {
+  _impl_.labels_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::set_labels(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.labels_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::set_labels(int index, const char* value, size_t size) {
+  _impl_.labels_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.labels)
+}
+inline std::string* WebMessageInfo::_internal_add_labels() {
+  return _impl_.labels_.Add();
+}
+inline void WebMessageInfo::add_labels(const std::string& value) {
+  _impl_.labels_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::add_labels(std::string&& value) {
+  _impl_.labels_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::add_labels(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.labels_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.labels)
+}
+inline void WebMessageInfo::add_labels(const char* value, size_t size) {
+  _impl_.labels_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.labels)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WebMessageInfo::labels() const {
+  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.labels)
+  return _impl_.labels_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WebMessageInfo::mutable_labels() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.labels)
+  return &_impl_.labels_;
+}
+
+// optional .proto.PaymentInfo paymentInfo = 29;
+inline bool WebMessageInfo::_internal_has_paymentinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.paymentinfo_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_paymentinfo() const {
+  return _internal_has_paymentinfo();
+}
+inline void WebMessageInfo::clear_paymentinfo() {
+  if (_impl_.paymentinfo_ != nullptr) _impl_.paymentinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline const ::proto::PaymentInfo& WebMessageInfo::_internal_paymentinfo() const {
+  const ::proto::PaymentInfo* p = _impl_.paymentinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentInfo&>(
+      ::proto::_PaymentInfo_default_instance_);
+}
+inline const ::proto::PaymentInfo& WebMessageInfo::paymentinfo() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.paymentInfo)
+  return _internal_paymentinfo();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_paymentinfo(
+    ::proto::PaymentInfo* paymentinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinfo_);
+  }
+  _impl_.paymentinfo_ = paymentinfo;
+  if (paymentinfo) {
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.paymentInfo)
+}
+inline ::proto::PaymentInfo* WebMessageInfo::release_paymentinfo() {
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::PaymentInfo* temp = _impl_.paymentinfo_;
+  _impl_.paymentinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_paymentinfo() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.paymentInfo)
+  _impl_._has_bits_[0] &= ~0x00000400u;
+  ::proto::PaymentInfo* temp = _impl_.paymentinfo_;
+  _impl_.paymentinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_paymentinfo() {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  if (_impl_.paymentinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation());
+    _impl_.paymentinfo_ = p;
+  }
+  return _impl_.paymentinfo_;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::mutable_paymentinfo() {
+  ::proto::PaymentInfo* _msg = _internal_mutable_paymentinfo();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.paymentInfo)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.paymentinfo_;
+  }
+  if (paymentinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinfo);
+    if (message_arena != submessage_arena) {
+      paymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, paymentinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000400u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000400u;
+  }
+  _impl_.paymentinfo_ = paymentinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.paymentInfo)
+}
+
+// optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
+inline bool WebMessageInfo::_internal_has_finallivelocation() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.finallivelocation_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_finallivelocation() const {
+  return _internal_has_finallivelocation();
+}
+inline void WebMessageInfo::clear_finallivelocation() {
+  if (_impl_.finallivelocation_ != nullptr) _impl_.finallivelocation_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::_internal_finallivelocation() const {
+  const ::proto::Message_LiveLocationMessage* p = _impl_.finallivelocation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LiveLocationMessage&>(
+      ::proto::_Message_LiveLocationMessage_default_instance_);
+}
+inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::finallivelocation() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.finalLiveLocation)
+  return _internal_finallivelocation();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_finallivelocation(
+    ::proto::Message_LiveLocationMessage* finallivelocation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.finallivelocation_);
+  }
+  _impl_.finallivelocation_ = finallivelocation;
+  if (finallivelocation) {
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.finalLiveLocation)
+}
+inline ::proto::Message_LiveLocationMessage* WebMessageInfo::release_finallivelocation() {
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_;
+  _impl_.finallivelocation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::Message_LiveLocationMessage* WebMessageInfo::unsafe_arena_release_finallivelocation() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.finalLiveLocation)
+  _impl_._has_bits_[0] &= ~0x00000800u;
+  ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_;
+  _impl_.finallivelocation_ = nullptr;
+  return temp;
+}
+inline ::proto::Message_LiveLocationMessage* WebMessageInfo::_internal_mutable_finallivelocation() {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  if (_impl_.finallivelocation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation());
+    _impl_.finallivelocation_ = p;
+  }
+  return _impl_.finallivelocation_;
+}
+inline ::proto::Message_LiveLocationMessage* WebMessageInfo::mutable_finallivelocation() {
+  ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_finallivelocation();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.finalLiveLocation)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.finallivelocation_;
+  }
+  if (finallivelocation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(finallivelocation);
+    if (message_arena != submessage_arena) {
+      finallivelocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, finallivelocation, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000800u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000800u;
+  }
+  _impl_.finallivelocation_ = finallivelocation;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.finalLiveLocation)
+}
+
+// optional .proto.PaymentInfo quotedPaymentInfo = 31;
+inline bool WebMessageInfo::_internal_has_quotedpaymentinfo() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quotedpaymentinfo_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_quotedpaymentinfo() const {
+  return _internal_has_quotedpaymentinfo();
+}
+inline void WebMessageInfo::clear_quotedpaymentinfo() {
+  if (_impl_.quotedpaymentinfo_ != nullptr) _impl_.quotedpaymentinfo_->Clear();
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline const ::proto::PaymentInfo& WebMessageInfo::_internal_quotedpaymentinfo() const {
+  const ::proto::PaymentInfo* p = _impl_.quotedpaymentinfo_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentInfo&>(
+      ::proto::_PaymentInfo_default_instance_);
+}
+inline const ::proto::PaymentInfo& WebMessageInfo::quotedpaymentinfo() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedPaymentInfo)
+  return _internal_quotedpaymentinfo();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_quotedpaymentinfo(
+    ::proto::PaymentInfo* quotedpaymentinfo) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedpaymentinfo_);
+  }
+  _impl_.quotedpaymentinfo_ = quotedpaymentinfo;
+  if (quotedpaymentinfo) {
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedPaymentInfo)
+}
+inline ::proto::PaymentInfo* WebMessageInfo::release_quotedpaymentinfo() {
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_;
+  _impl_.quotedpaymentinfo_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_quotedpaymentinfo() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedPaymentInfo)
+  _impl_._has_bits_[0] &= ~0x00001000u;
+  ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_;
+  _impl_.quotedpaymentinfo_ = nullptr;
+  return temp;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_quotedpaymentinfo() {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  if (_impl_.quotedpaymentinfo_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation());
+    _impl_.quotedpaymentinfo_ = p;
+  }
+  return _impl_.quotedpaymentinfo_;
+}
+inline ::proto::PaymentInfo* WebMessageInfo::mutable_quotedpaymentinfo() {
+  ::proto::PaymentInfo* _msg = _internal_mutable_quotedpaymentinfo();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedPaymentInfo)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quotedpaymentinfo_;
+  }
+  if (quotedpaymentinfo) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedpaymentinfo);
+    if (message_arena != submessage_arena) {
+      quotedpaymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quotedpaymentinfo, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00001000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00001000u;
+  }
+  _impl_.quotedpaymentinfo_ = quotedpaymentinfo;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedPaymentInfo)
+}
+
+// optional uint64 ephemeralStartTimestamp = 32;
+inline bool WebMessageInfo::_internal_has_ephemeralstarttimestamp() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_ephemeralstarttimestamp() const {
+  return _internal_has_ephemeralstarttimestamp();
+}
+inline void WebMessageInfo::clear_ephemeralstarttimestamp() {
+  _impl_.ephemeralstarttimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[1] &= ~0x00000002u;
+}
+inline uint64_t WebMessageInfo::_internal_ephemeralstarttimestamp() const {
+  return _impl_.ephemeralstarttimestamp_;
+}
+inline uint64_t WebMessageInfo::ephemeralstarttimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralStartTimestamp)
+  return _internal_ephemeralstarttimestamp();
+}
+inline void WebMessageInfo::_internal_set_ephemeralstarttimestamp(uint64_t value) {
+  _impl_._has_bits_[1] |= 0x00000002u;
+  _impl_.ephemeralstarttimestamp_ = value;
+}
+inline void WebMessageInfo::set_ephemeralstarttimestamp(uint64_t value) {
+  _internal_set_ephemeralstarttimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralStartTimestamp)
+}
+
+// optional uint32 ephemeralDuration = 33;
+inline bool WebMessageInfo::_internal_has_ephemeralduration() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_ephemeralduration() const {
+  return _internal_has_ephemeralduration();
+}
+inline void WebMessageInfo::clear_ephemeralduration() {
+  _impl_.ephemeralduration_ = 0u;
+  _impl_._has_bits_[1] &= ~0x00000001u;
+}
+inline uint32_t WebMessageInfo::_internal_ephemeralduration() const {
+  return _impl_.ephemeralduration_;
+}
+inline uint32_t WebMessageInfo::ephemeralduration() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralDuration)
+  return _internal_ephemeralduration();
+}
+inline void WebMessageInfo::_internal_set_ephemeralduration(uint32_t value) {
+  _impl_._has_bits_[1] |= 0x00000001u;
+  _impl_.ephemeralduration_ = value;
+}
+inline void WebMessageInfo::set_ephemeralduration(uint32_t value) {
+  _internal_set_ephemeralduration(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralDuration)
+}
+
+// optional bool ephemeralOffToOn = 34;
+inline bool WebMessageInfo::_internal_has_ephemeralofftoon() const {
+  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_ephemeralofftoon() const {
+  return _internal_has_ephemeralofftoon();
+}
+inline void WebMessageInfo::clear_ephemeralofftoon() {
+  _impl_.ephemeralofftoon_ = false;
+  _impl_._has_bits_[0] &= ~0x40000000u;
+}
+inline bool WebMessageInfo::_internal_ephemeralofftoon() const {
+  return _impl_.ephemeralofftoon_;
+}
+inline bool WebMessageInfo::ephemeralofftoon() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOffToOn)
+  return _internal_ephemeralofftoon();
+}
+inline void WebMessageInfo::_internal_set_ephemeralofftoon(bool value) {
+  _impl_._has_bits_[0] |= 0x40000000u;
+  _impl_.ephemeralofftoon_ = value;
+}
+inline void WebMessageInfo::set_ephemeralofftoon(bool value) {
+  _internal_set_ephemeralofftoon(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOffToOn)
+}
+
+// optional bool ephemeralOutOfSync = 35;
+inline bool WebMessageInfo::_internal_has_ephemeraloutofsync() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_ephemeraloutofsync() const {
+  return _internal_has_ephemeraloutofsync();
+}
+inline void WebMessageInfo::clear_ephemeraloutofsync() {
+  _impl_.ephemeraloutofsync_ = false;
+  _impl_._has_bits_[1] &= ~0x00000008u;
+}
+inline bool WebMessageInfo::_internal_ephemeraloutofsync() const {
+  return _impl_.ephemeraloutofsync_;
+}
+inline bool WebMessageInfo::ephemeraloutofsync() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOutOfSync)
+  return _internal_ephemeraloutofsync();
+}
+inline void WebMessageInfo::_internal_set_ephemeraloutofsync(bool value) {
+  _impl_._has_bits_[1] |= 0x00000008u;
+  _impl_.ephemeraloutofsync_ = value;
+}
+inline void WebMessageInfo::set_ephemeraloutofsync(bool value) {
+  _internal_set_ephemeraloutofsync(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOutOfSync)
+}
+
+// optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
+inline bool WebMessageInfo::_internal_has_bizprivacystatus() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_bizprivacystatus() const {
+  return _internal_has_bizprivacystatus();
+}
+inline void WebMessageInfo::clear_bizprivacystatus() {
+  _impl_.bizprivacystatus_ = 0;
+  _impl_._has_bits_[1] &= ~0x00000004u;
+}
+inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::_internal_bizprivacystatus() const {
+  return static_cast< ::proto::WebMessageInfo_BizPrivacyStatus >(_impl_.bizprivacystatus_);
+}
+inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::bizprivacystatus() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.bizPrivacyStatus)
+  return _internal_bizprivacystatus();
+}
+inline void WebMessageInfo::_internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) {
+  assert(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(value));
+  _impl_._has_bits_[1] |= 0x00000004u;
+  _impl_.bizprivacystatus_ = value;
+}
+inline void WebMessageInfo::set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) {
+  _internal_set_bizprivacystatus(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.bizPrivacyStatus)
+}
+
+// optional string verifiedBizName = 37;
+inline bool WebMessageInfo::_internal_has_verifiedbizname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_verifiedbizname() const {
+  return _internal_has_verifiedbizname();
+}
+inline void WebMessageInfo::clear_verifiedbizname() {
+  _impl_.verifiedbizname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& WebMessageInfo::verifiedbizname() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.verifiedBizName)
+  return _internal_verifiedbizname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_verifiedbizname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.verifiedbizname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.verifiedBizName)
+}
+inline std::string* WebMessageInfo::mutable_verifiedbizname() {
+  std::string* _s = _internal_mutable_verifiedbizname();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.verifiedBizName)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_verifiedbizname() const {
+  return _impl_.verifiedbizname_.Get();
+}
+inline void WebMessageInfo::_internal_set_verifiedbizname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.verifiedbizname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_verifiedbizname() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.verifiedbizname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_verifiedbizname() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.verifiedBizName)
+  if (!_internal_has_verifiedbizname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.verifiedbizname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedbizname_.IsDefault()) {
+    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_verifiedbizname(std::string* verifiedbizname) {
+  if (verifiedbizname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.verifiedbizname_.SetAllocated(verifiedbizname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verifiedbizname_.IsDefault()) {
+    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.verifiedBizName)
+}
+
+// optional .proto.MediaData mediaData = 38;
+inline bool WebMessageInfo::_internal_has_mediadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_mediadata() const {
+  return _internal_has_mediadata();
+}
+inline void WebMessageInfo::clear_mediadata() {
+  if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline const ::proto::MediaData& WebMessageInfo::_internal_mediadata() const {
+  const ::proto::MediaData* p = _impl_.mediadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MediaData&>(
+      ::proto::_MediaData_default_instance_);
+}
+inline const ::proto::MediaData& WebMessageInfo::mediadata() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaData)
+  return _internal_mediadata();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_mediadata(
+    ::proto::MediaData* mediadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_);
+  }
+  _impl_.mediadata_ = mediadata;
+  if (mediadata) {
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.mediaData)
+}
+inline ::proto::MediaData* WebMessageInfo::release_mediadata() {
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::MediaData* temp = _impl_.mediadata_;
+  _impl_.mediadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_mediadata() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaData)
+  _impl_._has_bits_[0] &= ~0x00002000u;
+  ::proto::MediaData* temp = _impl_.mediadata_;
+  _impl_.mediadata_ = nullptr;
+  return temp;
+}
+inline ::proto::MediaData* WebMessageInfo::_internal_mutable_mediadata() {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  if (_impl_.mediadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation());
+    _impl_.mediadata_ = p;
+  }
+  return _impl_.mediadata_;
+}
+inline ::proto::MediaData* WebMessageInfo::mutable_mediadata() {
+  ::proto::MediaData* _msg = _internal_mutable_mediadata();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaData)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_mediadata(::proto::MediaData* mediadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.mediadata_;
+  }
+  if (mediadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata);
+    if (message_arena != submessage_arena) {
+      mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, mediadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00002000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00002000u;
+  }
+  _impl_.mediadata_ = mediadata;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaData)
+}
+
+// optional .proto.PhotoChange photoChange = 39;
+inline bool WebMessageInfo::_internal_has_photochange() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.photochange_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_photochange() const {
+  return _internal_has_photochange();
+}
+inline void WebMessageInfo::clear_photochange() {
+  if (_impl_.photochange_ != nullptr) _impl_.photochange_->Clear();
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline const ::proto::PhotoChange& WebMessageInfo::_internal_photochange() const {
+  const ::proto::PhotoChange* p = _impl_.photochange_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PhotoChange&>(
+      ::proto::_PhotoChange_default_instance_);
+}
+inline const ::proto::PhotoChange& WebMessageInfo::photochange() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.photoChange)
+  return _internal_photochange();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_photochange(
+    ::proto::PhotoChange* photochange) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.photochange_);
+  }
+  _impl_.photochange_ = photochange;
+  if (photochange) {
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.photoChange)
+}
+inline ::proto::PhotoChange* WebMessageInfo::release_photochange() {
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::PhotoChange* temp = _impl_.photochange_;
+  _impl_.photochange_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PhotoChange* WebMessageInfo::unsafe_arena_release_photochange() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.photoChange)
+  _impl_._has_bits_[0] &= ~0x00004000u;
+  ::proto::PhotoChange* temp = _impl_.photochange_;
+  _impl_.photochange_ = nullptr;
+  return temp;
+}
+inline ::proto::PhotoChange* WebMessageInfo::_internal_mutable_photochange() {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  if (_impl_.photochange_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PhotoChange>(GetArenaForAllocation());
+    _impl_.photochange_ = p;
+  }
+  return _impl_.photochange_;
+}
+inline ::proto::PhotoChange* WebMessageInfo::mutable_photochange() {
+  ::proto::PhotoChange* _msg = _internal_mutable_photochange();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.photoChange)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_photochange(::proto::PhotoChange* photochange) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.photochange_;
+  }
+  if (photochange) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(photochange);
+    if (message_arena != submessage_arena) {
+      photochange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, photochange, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00004000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00004000u;
+  }
+  _impl_.photochange_ = photochange;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.photoChange)
+}
+
+// repeated .proto.UserReceipt userReceipt = 40;
+inline int WebMessageInfo::_internal_userreceipt_size() const {
+  return _impl_.userreceipt_.size();
+}
+inline int WebMessageInfo::userreceipt_size() const {
+  return _internal_userreceipt_size();
+}
+inline void WebMessageInfo::clear_userreceipt() {
+  _impl_.userreceipt_.Clear();
+}
+inline ::proto::UserReceipt* WebMessageInfo::mutable_userreceipt(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.userReceipt)
+  return _impl_.userreceipt_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >*
+WebMessageInfo::mutable_userreceipt() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.userReceipt)
+  return &_impl_.userreceipt_;
+}
+inline const ::proto::UserReceipt& WebMessageInfo::_internal_userreceipt(int index) const {
+  return _impl_.userreceipt_.Get(index);
+}
+inline const ::proto::UserReceipt& WebMessageInfo::userreceipt(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.userReceipt)
+  return _internal_userreceipt(index);
+}
+inline ::proto::UserReceipt* WebMessageInfo::_internal_add_userreceipt() {
+  return _impl_.userreceipt_.Add();
+}
+inline ::proto::UserReceipt* WebMessageInfo::add_userreceipt() {
+  ::proto::UserReceipt* _add = _internal_add_userreceipt();
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.userReceipt)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >&
+WebMessageInfo::userreceipt() const {
+  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.userReceipt)
+  return _impl_.userreceipt_;
+}
+
+// repeated .proto.Reaction reactions = 41;
+inline int WebMessageInfo::_internal_reactions_size() const {
+  return _impl_.reactions_.size();
+}
+inline int WebMessageInfo::reactions_size() const {
+  return _internal_reactions_size();
+}
+inline void WebMessageInfo::clear_reactions() {
+  _impl_.reactions_.Clear();
+}
+inline ::proto::Reaction* WebMessageInfo::mutable_reactions(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.reactions)
+  return _impl_.reactions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >*
+WebMessageInfo::mutable_reactions() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.reactions)
+  return &_impl_.reactions_;
+}
+inline const ::proto::Reaction& WebMessageInfo::_internal_reactions(int index) const {
+  return _impl_.reactions_.Get(index);
+}
+inline const ::proto::Reaction& WebMessageInfo::reactions(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.reactions)
+  return _internal_reactions(index);
+}
+inline ::proto::Reaction* WebMessageInfo::_internal_add_reactions() {
+  return _impl_.reactions_.Add();
+}
+inline ::proto::Reaction* WebMessageInfo::add_reactions() {
+  ::proto::Reaction* _add = _internal_add_reactions();
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.reactions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >&
+WebMessageInfo::reactions() const {
+  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.reactions)
+  return _impl_.reactions_;
+}
+
+// optional .proto.MediaData quotedStickerData = 42;
+inline bool WebMessageInfo::_internal_has_quotedstickerdata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.quotedstickerdata_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_quotedstickerdata() const {
+  return _internal_has_quotedstickerdata();
+}
+inline void WebMessageInfo::clear_quotedstickerdata() {
+  if (_impl_.quotedstickerdata_ != nullptr) _impl_.quotedstickerdata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline const ::proto::MediaData& WebMessageInfo::_internal_quotedstickerdata() const {
+  const ::proto::MediaData* p = _impl_.quotedstickerdata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::MediaData&>(
+      ::proto::_MediaData_default_instance_);
+}
+inline const ::proto::MediaData& WebMessageInfo::quotedstickerdata() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedStickerData)
+  return _internal_quotedstickerdata();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_quotedstickerdata(
+    ::proto::MediaData* quotedstickerdata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedstickerdata_);
+  }
+  _impl_.quotedstickerdata_ = quotedstickerdata;
+  if (quotedstickerdata) {
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedStickerData)
+}
+inline ::proto::MediaData* WebMessageInfo::release_quotedstickerdata() {
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::MediaData* temp = _impl_.quotedstickerdata_;
+  _impl_.quotedstickerdata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_quotedstickerdata() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedStickerData)
+  _impl_._has_bits_[0] &= ~0x00008000u;
+  ::proto::MediaData* temp = _impl_.quotedstickerdata_;
+  _impl_.quotedstickerdata_ = nullptr;
+  return temp;
+}
+inline ::proto::MediaData* WebMessageInfo::_internal_mutable_quotedstickerdata() {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  if (_impl_.quotedstickerdata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation());
+    _impl_.quotedstickerdata_ = p;
+  }
+  return _impl_.quotedstickerdata_;
+}
+inline ::proto::MediaData* WebMessageInfo::mutable_quotedstickerdata() {
+  ::proto::MediaData* _msg = _internal_mutable_quotedstickerdata();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedStickerData)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.quotedstickerdata_;
+  }
+  if (quotedstickerdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedstickerdata);
+    if (message_arena != submessage_arena) {
+      quotedstickerdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, quotedstickerdata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00008000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00008000u;
+  }
+  _impl_.quotedstickerdata_ = quotedstickerdata;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedStickerData)
+}
+
+// optional bytes futureproofData = 43;
+inline bool WebMessageInfo::_internal_has_futureproofdata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_futureproofdata() const {
+  return _internal_has_futureproofdata();
+}
+inline void WebMessageInfo::clear_futureproofdata() {
+  _impl_.futureproofdata_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& WebMessageInfo::futureproofdata() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.futureproofData)
+  return _internal_futureproofdata();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_futureproofdata(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.futureproofdata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.futureproofData)
+}
+inline std::string* WebMessageInfo::mutable_futureproofdata() {
+  std::string* _s = _internal_mutable_futureproofdata();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.futureproofData)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_futureproofdata() const {
+  return _impl_.futureproofdata_.Get();
+}
+inline void WebMessageInfo::_internal_set_futureproofdata(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.futureproofdata_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_futureproofdata() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.futureproofdata_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_futureproofdata() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.futureproofData)
+  if (!_internal_has_futureproofdata()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.futureproofdata_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.futureproofdata_.IsDefault()) {
+    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_futureproofdata(std::string* futureproofdata) {
+  if (futureproofdata != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.futureproofdata_.SetAllocated(futureproofdata, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.futureproofdata_.IsDefault()) {
+    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.futureproofData)
+}
+
+// optional .proto.StatusPSA statusPsa = 44;
+inline bool WebMessageInfo::_internal_has_statuspsa() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.statuspsa_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_statuspsa() const {
+  return _internal_has_statuspsa();
+}
+inline void WebMessageInfo::clear_statuspsa() {
+  if (_impl_.statuspsa_ != nullptr) _impl_.statuspsa_->Clear();
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline const ::proto::StatusPSA& WebMessageInfo::_internal_statuspsa() const {
+  const ::proto::StatusPSA* p = _impl_.statuspsa_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::StatusPSA&>(
+      ::proto::_StatusPSA_default_instance_);
+}
+inline const ::proto::StatusPSA& WebMessageInfo::statuspsa() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusPsa)
+  return _internal_statuspsa();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_statuspsa(
+    ::proto::StatusPSA* statuspsa) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.statuspsa_);
+  }
+  _impl_.statuspsa_ = statuspsa;
+  if (statuspsa) {
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.statusPsa)
+}
+inline ::proto::StatusPSA* WebMessageInfo::release_statuspsa() {
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::StatusPSA* temp = _impl_.statuspsa_;
+  _impl_.statuspsa_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::StatusPSA* WebMessageInfo::unsafe_arena_release_statuspsa() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.statusPsa)
+  _impl_._has_bits_[0] &= ~0x00010000u;
+  ::proto::StatusPSA* temp = _impl_.statuspsa_;
+  _impl_.statuspsa_ = nullptr;
+  return temp;
+}
+inline ::proto::StatusPSA* WebMessageInfo::_internal_mutable_statuspsa() {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  if (_impl_.statuspsa_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::StatusPSA>(GetArenaForAllocation());
+    _impl_.statuspsa_ = p;
+  }
+  return _impl_.statuspsa_;
+}
+inline ::proto::StatusPSA* WebMessageInfo::mutable_statuspsa() {
+  ::proto::StatusPSA* _msg = _internal_mutable_statuspsa();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.statusPsa)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_statuspsa(::proto::StatusPSA* statuspsa) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.statuspsa_;
+  }
+  if (statuspsa) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(statuspsa);
+    if (message_arena != submessage_arena) {
+      statuspsa = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, statuspsa, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00010000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00010000u;
+  }
+  _impl_.statuspsa_ = statuspsa;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.statusPsa)
+}
+
+// repeated .proto.PollUpdate pollUpdates = 45;
+inline int WebMessageInfo::_internal_pollupdates_size() const {
+  return _impl_.pollupdates_.size();
+}
+inline int WebMessageInfo::pollupdates_size() const {
+  return _internal_pollupdates_size();
+}
+inline void WebMessageInfo::clear_pollupdates() {
+  _impl_.pollupdates_.Clear();
+}
+inline ::proto::PollUpdate* WebMessageInfo::mutable_pollupdates(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollUpdates)
+  return _impl_.pollupdates_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >*
+WebMessageInfo::mutable_pollupdates() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.pollUpdates)
+  return &_impl_.pollupdates_;
+}
+inline const ::proto::PollUpdate& WebMessageInfo::_internal_pollupdates(int index) const {
+  return _impl_.pollupdates_.Get(index);
+}
+inline const ::proto::PollUpdate& WebMessageInfo::pollupdates(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollUpdates)
+  return _internal_pollupdates(index);
+}
+inline ::proto::PollUpdate* WebMessageInfo::_internal_add_pollupdates() {
+  return _impl_.pollupdates_.Add();
+}
+inline ::proto::PollUpdate* WebMessageInfo::add_pollupdates() {
+  ::proto::PollUpdate* _add = _internal_add_pollupdates();
+  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.pollUpdates)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >&
+WebMessageInfo::pollupdates() const {
+  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.pollUpdates)
+  return _impl_.pollupdates_;
+}
+
+// optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
+inline bool WebMessageInfo::_internal_has_polladditionalmetadata() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.polladditionalmetadata_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_polladditionalmetadata() const {
+  return _internal_has_polladditionalmetadata();
+}
+inline void WebMessageInfo::clear_polladditionalmetadata() {
+  if (_impl_.polladditionalmetadata_ != nullptr) _impl_.polladditionalmetadata_->Clear();
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline const ::proto::PollAdditionalMetadata& WebMessageInfo::_internal_polladditionalmetadata() const {
+  const ::proto::PollAdditionalMetadata* p = _impl_.polladditionalmetadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::PollAdditionalMetadata&>(
+      ::proto::_PollAdditionalMetadata_default_instance_);
+}
+inline const ::proto::PollAdditionalMetadata& WebMessageInfo::polladditionalmetadata() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollAdditionalMetadata)
+  return _internal_polladditionalmetadata();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_polladditionalmetadata(
+    ::proto::PollAdditionalMetadata* polladditionalmetadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polladditionalmetadata_);
+  }
+  _impl_.polladditionalmetadata_ = polladditionalmetadata;
+  if (polladditionalmetadata) {
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata)
+}
+inline ::proto::PollAdditionalMetadata* WebMessageInfo::release_polladditionalmetadata() {
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_;
+  _impl_.polladditionalmetadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::PollAdditionalMetadata* WebMessageInfo::unsafe_arena_release_polladditionalmetadata() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pollAdditionalMetadata)
+  _impl_._has_bits_[0] &= ~0x00020000u;
+  ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_;
+  _impl_.polladditionalmetadata_ = nullptr;
+  return temp;
+}
+inline ::proto::PollAdditionalMetadata* WebMessageInfo::_internal_mutable_polladditionalmetadata() {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  if (_impl_.polladditionalmetadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::PollAdditionalMetadata>(GetArenaForAllocation());
+    _impl_.polladditionalmetadata_ = p;
+  }
+  return _impl_.polladditionalmetadata_;
+}
+inline ::proto::PollAdditionalMetadata* WebMessageInfo::mutable_polladditionalmetadata() {
+  ::proto::PollAdditionalMetadata* _msg = _internal_mutable_polladditionalmetadata();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollAdditionalMetadata)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.polladditionalmetadata_;
+  }
+  if (polladditionalmetadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(polladditionalmetadata);
+    if (message_arena != submessage_arena) {
+      polladditionalmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, polladditionalmetadata, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00020000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00020000u;
+  }
+  _impl_.polladditionalmetadata_ = polladditionalmetadata;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata)
+}
+
+// optional string agentId = 47;
+inline bool WebMessageInfo::_internal_has_agentid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_agentid() const {
+  return _internal_has_agentid();
+}
+inline void WebMessageInfo::clear_agentid() {
+  _impl_.agentid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& WebMessageInfo::agentid() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.agentId)
+  return _internal_agentid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_agentid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.agentid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.agentId)
+}
+inline std::string* WebMessageInfo::mutable_agentid() {
+  std::string* _s = _internal_mutable_agentid();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.agentId)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_agentid() const {
+  return _impl_.agentid_.Get();
+}
+inline void WebMessageInfo::_internal_set_agentid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.agentid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_agentid() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.agentid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_agentid() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.agentId)
+  if (!_internal_has_agentid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.agentid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.agentid_.IsDefault()) {
+    _impl_.agentid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_agentid(std::string* agentid) {
+  if (agentid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.agentid_.SetAllocated(agentid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.agentid_.IsDefault()) {
+    _impl_.agentid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.agentId)
+}
+
+// optional bool statusAlreadyViewed = 48;
+inline bool WebMessageInfo::_internal_has_statusalreadyviewed() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_statusalreadyviewed() const {
+  return _internal_has_statusalreadyviewed();
+}
+inline void WebMessageInfo::clear_statusalreadyviewed() {
+  _impl_.statusalreadyviewed_ = false;
+  _impl_._has_bits_[1] &= ~0x00000010u;
+}
+inline bool WebMessageInfo::_internal_statusalreadyviewed() const {
+  return _impl_.statusalreadyviewed_;
+}
+inline bool WebMessageInfo::statusalreadyviewed() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusAlreadyViewed)
+  return _internal_statusalreadyviewed();
+}
+inline void WebMessageInfo::_internal_set_statusalreadyviewed(bool value) {
+  _impl_._has_bits_[1] |= 0x00000010u;
+  _impl_.statusalreadyviewed_ = value;
+}
+inline void WebMessageInfo::set_statusalreadyviewed(bool value) {
+  _internal_set_statusalreadyviewed(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.statusAlreadyViewed)
+}
+
+// optional bytes messageSecret = 49;
+inline bool WebMessageInfo::_internal_has_messagesecret() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_messagesecret() const {
+  return _internal_has_messagesecret();
+}
+inline void WebMessageInfo::clear_messagesecret() {
+  _impl_.messagesecret_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& WebMessageInfo::messagesecret() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageSecret)
+  return _internal_messagesecret();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageSecret)
+}
+inline std::string* WebMessageInfo::mutable_messagesecret() {
+  std::string* _s = _internal_mutable_messagesecret();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageSecret)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_messagesecret() const {
+  return _impl_.messagesecret_.Get();
+}
+inline void WebMessageInfo::_internal_set_messagesecret(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_messagesecret() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_messagesecret() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.messageSecret)
+  if (!_internal_has_messagesecret()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.messagesecret_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_messagesecret(std::string* messagesecret) {
+  if (messagesecret != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.messagesecret_.IsDefault()) {
+    _impl_.messagesecret_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.messageSecret)
+}
+
+// optional .proto.KeepInChat keepInChat = 50;
+inline bool WebMessageInfo::_internal_has_keepinchat() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.keepinchat_ != nullptr);
+  return value;
+}
+inline bool WebMessageInfo::has_keepinchat() const {
+  return _internal_has_keepinchat();
+}
+inline void WebMessageInfo::clear_keepinchat() {
+  if (_impl_.keepinchat_ != nullptr) _impl_.keepinchat_->Clear();
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline const ::proto::KeepInChat& WebMessageInfo::_internal_keepinchat() const {
+  const ::proto::KeepInChat* p = _impl_.keepinchat_;
+  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeepInChat&>(
+      ::proto::_KeepInChat_default_instance_);
+}
+inline const ::proto::KeepInChat& WebMessageInfo::keepinchat() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.keepInChat)
+  return _internal_keepinchat();
+}
+inline void WebMessageInfo::unsafe_arena_set_allocated_keepinchat(
+    ::proto::KeepInChat* keepinchat) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchat_);
+  }
+  _impl_.keepinchat_ = keepinchat;
+  if (keepinchat) {
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.keepInChat)
+}
+inline ::proto::KeepInChat* WebMessageInfo::release_keepinchat() {
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::KeepInChat* temp = _impl_.keepinchat_;
+  _impl_.keepinchat_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::proto::KeepInChat* WebMessageInfo::unsafe_arena_release_keepinchat() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.keepInChat)
+  _impl_._has_bits_[0] &= ~0x00040000u;
+  ::proto::KeepInChat* temp = _impl_.keepinchat_;
+  _impl_.keepinchat_ = nullptr;
+  return temp;
+}
+inline ::proto::KeepInChat* WebMessageInfo::_internal_mutable_keepinchat() {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  if (_impl_.keepinchat_ == nullptr) {
+    auto* p = CreateMaybeMessage<::proto::KeepInChat>(GetArenaForAllocation());
+    _impl_.keepinchat_ = p;
+  }
+  return _impl_.keepinchat_;
+}
+inline ::proto::KeepInChat* WebMessageInfo::mutable_keepinchat() {
+  ::proto::KeepInChat* _msg = _internal_mutable_keepinchat();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.keepInChat)
+  return _msg;
+}
+inline void WebMessageInfo::set_allocated_keepinchat(::proto::KeepInChat* keepinchat) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.keepinchat_;
+  }
+  if (keepinchat) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchat);
+    if (message_arena != submessage_arena) {
+      keepinchat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, keepinchat, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00040000u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00040000u;
+  }
+  _impl_.keepinchat_ = keepinchat;
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.keepInChat)
+}
+
+// optional string originalSelfAuthorUserJidString = 51;
+inline bool WebMessageInfo::_internal_has_originalselfauthoruserjidstring() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_originalselfauthoruserjidstring() const {
+  return _internal_has_originalselfauthoruserjidstring();
+}
+inline void WebMessageInfo::clear_originalselfauthoruserjidstring() {
+  _impl_.originalselfauthoruserjidstring_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& WebMessageInfo::originalselfauthoruserjidstring() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.originalSelfAuthorUserJidString)
+  return _internal_originalselfauthoruserjidstring();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WebMessageInfo::set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.originalselfauthoruserjidstring_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.originalSelfAuthorUserJidString)
+}
+inline std::string* WebMessageInfo::mutable_originalselfauthoruserjidstring() {
+  std::string* _s = _internal_mutable_originalselfauthoruserjidstring();
+  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.originalSelfAuthorUserJidString)
+  return _s;
+}
+inline const std::string& WebMessageInfo::_internal_originalselfauthoruserjidstring() const {
+  return _impl_.originalselfauthoruserjidstring_.Get();
+}
+inline void WebMessageInfo::_internal_set_originalselfauthoruserjidstring(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.originalselfauthoruserjidstring_.Set(value, GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::_internal_mutable_originalselfauthoruserjidstring() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.originalselfauthoruserjidstring_.Mutable(GetArenaForAllocation());
+}
+inline std::string* WebMessageInfo::release_originalselfauthoruserjidstring() {
+  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.originalSelfAuthorUserJidString)
+  if (!_internal_has_originalselfauthoruserjidstring()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.originalselfauthoruserjidstring_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.originalselfauthoruserjidstring_.IsDefault()) {
+    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void WebMessageInfo::set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring) {
+  if (originalselfauthoruserjidstring != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.originalselfauthoruserjidstring_.SetAllocated(originalselfauthoruserjidstring, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.originalselfauthoruserjidstring_.IsDefault()) {
+    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.originalSelfAuthorUserJidString)
+}
+
+// optional uint64 revokeMessageTimestamp = 52;
+inline bool WebMessageInfo::_internal_has_revokemessagetimestamp() const {
+  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WebMessageInfo::has_revokemessagetimestamp() const {
+  return _internal_has_revokemessagetimestamp();
+}
+inline void WebMessageInfo::clear_revokemessagetimestamp() {
+  _impl_.revokemessagetimestamp_ = uint64_t{0u};
+  _impl_._has_bits_[1] &= ~0x00000020u;
+}
+inline uint64_t WebMessageInfo::_internal_revokemessagetimestamp() const {
+  return _impl_.revokemessagetimestamp_;
+}
+inline uint64_t WebMessageInfo::revokemessagetimestamp() const {
+  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.revokeMessageTimestamp)
+  return _internal_revokemessagetimestamp();
+}
+inline void WebMessageInfo::_internal_set_revokemessagetimestamp(uint64_t value) {
+  _impl_._has_bits_[1] |= 0x00000020u;
+  _impl_.revokemessagetimestamp_ = value;
+}
+inline void WebMessageInfo::set_revokemessagetimestamp(uint64_t value) {
+  _internal_set_revokemessagetimestamp(value);
+  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.revokeMessageTimestamp)
+}
+
+// -------------------------------------------------------------------
+
+// WebNotificationsInfo
+
+// optional uint64 timestamp = 2;
+inline bool WebNotificationsInfo::_internal_has_timestamp() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WebNotificationsInfo::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void WebNotificationsInfo::clear_timestamp() {
+  _impl_.timestamp_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t WebNotificationsInfo::_internal_timestamp() const {
+  return _impl_.timestamp_;
+}
+inline uint64_t WebNotificationsInfo::timestamp() const {
+  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.timestamp)
+  return _internal_timestamp();
+}
+inline void WebNotificationsInfo::_internal_set_timestamp(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.timestamp_ = value;
+}
+inline void WebNotificationsInfo::set_timestamp(uint64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.timestamp)
+}
+
+// optional uint32 unreadChats = 3;
+inline bool WebNotificationsInfo::_internal_has_unreadchats() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WebNotificationsInfo::has_unreadchats() const {
+  return _internal_has_unreadchats();
+}
+inline void WebNotificationsInfo::clear_unreadchats() {
+  _impl_.unreadchats_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t WebNotificationsInfo::_internal_unreadchats() const {
+  return _impl_.unreadchats_;
+}
+inline uint32_t WebNotificationsInfo::unreadchats() const {
+  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.unreadChats)
+  return _internal_unreadchats();
+}
+inline void WebNotificationsInfo::_internal_set_unreadchats(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.unreadchats_ = value;
+}
+inline void WebNotificationsInfo::set_unreadchats(uint32_t value) {
+  _internal_set_unreadchats(value);
+  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.unreadChats)
+}
+
+// optional uint32 notifyMessageCount = 4;
+inline bool WebNotificationsInfo::_internal_has_notifymessagecount() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WebNotificationsInfo::has_notifymessagecount() const {
+  return _internal_has_notifymessagecount();
+}
+inline void WebNotificationsInfo::clear_notifymessagecount() {
+  _impl_.notifymessagecount_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t WebNotificationsInfo::_internal_notifymessagecount() const {
+  return _impl_.notifymessagecount_;
+}
+inline uint32_t WebNotificationsInfo::notifymessagecount() const {
+  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessageCount)
+  return _internal_notifymessagecount();
+}
+inline void WebNotificationsInfo::_internal_set_notifymessagecount(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.notifymessagecount_ = value;
+}
+inline void WebNotificationsInfo::set_notifymessagecount(uint32_t value) {
+  _internal_set_notifymessagecount(value);
+  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.notifyMessageCount)
+}
+
+// repeated .proto.WebMessageInfo notifyMessages = 5;
+inline int WebNotificationsInfo::_internal_notifymessages_size() const {
+  return _impl_.notifymessages_.size();
+}
+inline int WebNotificationsInfo::notifymessages_size() const {
+  return _internal_notifymessages_size();
+}
+inline void WebNotificationsInfo::clear_notifymessages() {
+  _impl_.notifymessages_.Clear();
+}
+inline ::proto::WebMessageInfo* WebNotificationsInfo::mutable_notifymessages(int index) {
+  // @@protoc_insertion_point(field_mutable:proto.WebNotificationsInfo.notifyMessages)
+  return _impl_.notifymessages_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
+WebNotificationsInfo::mutable_notifymessages() {
+  // @@protoc_insertion_point(field_mutable_list:proto.WebNotificationsInfo.notifyMessages)
+  return &_impl_.notifymessages_;
+}
+inline const ::proto::WebMessageInfo& WebNotificationsInfo::_internal_notifymessages(int index) const {
+  return _impl_.notifymessages_.Get(index);
+}
+inline const ::proto::WebMessageInfo& WebNotificationsInfo::notifymessages(int index) const {
+  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessages)
+  return _internal_notifymessages(index);
+}
+inline ::proto::WebMessageInfo* WebNotificationsInfo::_internal_add_notifymessages() {
+  return _impl_.notifymessages_.Add();
+}
+inline ::proto::WebMessageInfo* WebNotificationsInfo::add_notifymessages() {
+  ::proto::WebMessageInfo* _add = _internal_add_notifymessages();
+  // @@protoc_insertion_point(field_add:proto.WebNotificationsInfo.notifyMessages)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
+WebNotificationsInfo::notifymessages() const {
+  // @@protoc_insertion_point(field_list:proto.WebNotificationsInfo.notifyMessages)
+  return _impl_.notifymessages_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace proto
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_AccountType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_AccountType>() {
+  return ::proto::BizAccountLinkInfo_AccountType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_HostStorageType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_HostStorageType>() {
+  return ::proto::BizAccountLinkInfo_HostStorageType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::BizIdentityInfo_ActualActorsType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_ActualActorsType>() {
+  return ::proto::BizIdentityInfo_ActualActorsType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::BizIdentityInfo_HostStorageType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_HostStorageType>() {
+  return ::proto::BizIdentityInfo_HostStorageType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::BizIdentityInfo_VerifiedLevelValue> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_VerifiedLevelValue>() {
+  return ::proto::BizIdentityInfo_VerifiedLevelValue_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_DNSSource_DNSResolutionMethod> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_DNSSource_DNSResolutionMethod>() {
+  return ::proto::ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_Platform> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_Platform>() {
+  return ::proto::ClientPayload_UserAgent_Platform_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_ReleaseChannel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_ReleaseChannel>() {
+  return ::proto::ClientPayload_UserAgent_ReleaseChannel_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_WebInfo_WebSubPlatform> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_WebInfo_WebSubPlatform>() {
+  return ::proto::ClientPayload_WebInfo_WebSubPlatform_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_ConnectReason> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectReason>() {
+  return ::proto::ClientPayload_ConnectReason_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_ConnectType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectType>() {
+  return ::proto::ClientPayload_ConnectType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_IOSAppExtension> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_IOSAppExtension>() {
+  return ::proto::ClientPayload_IOSAppExtension_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ClientPayload_Product> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_Product>() {
+  return ::proto::ClientPayload_Product_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ContextInfo_AdReplyInfo_MediaType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_AdReplyInfo_MediaType>() {
+  return ::proto::ContextInfo_AdReplyInfo_MediaType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType>() {
+  return ::proto::ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Conversation_EndOfHistoryTransferType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Conversation_EndOfHistoryTransferType>() {
+  return ::proto::Conversation_EndOfHistoryTransferType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::DeviceProps_PlatformType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::DeviceProps_PlatformType>() {
+  return ::proto::DeviceProps_PlatformType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::DisappearingMode_Initiator> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::DisappearingMode_Initiator>() {
+  return ::proto::DisappearingMode_Initiator_descriptor();
+}
+template <> struct is_proto_enum< ::proto::GroupParticipant_Rank> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::GroupParticipant_Rank>() {
+  return ::proto::GroupParticipant_Rank_descriptor();
+}
+template <> struct is_proto_enum< ::proto::HistorySync_HistorySyncType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::HistorySync_HistorySyncType>() {
+  return ::proto::HistorySync_HistorySyncType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::MediaRetryNotification_ResultType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaRetryNotification_ResultType>() {
+  return ::proto::MediaRetryNotification_ResultType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_Button_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_Button_Type>() {
+  return ::proto::Message_ButtonsMessage_Button_Type_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_HeaderType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_HeaderType>() {
+  return ::proto::Message_ButtonsMessage_HeaderType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ButtonsResponseMessage_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsResponseMessage_Type>() {
+  return ::proto::Message_ButtonsResponseMessage_Type_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_FontType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_FontType>() {
+  return ::proto::Message_ExtendedTextMessage_FontType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType>() {
+  return ::proto::Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_PreviewType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_PreviewType>() {
+  return ::proto::Message_ExtendedTextMessage_PreviewType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_GroupInviteMessage_GroupType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_GroupInviteMessage_GroupType>() {
+  return ::proto::Message_GroupInviteMessage_GroupType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>() {
+  return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>() {
+  return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_HistorySyncNotification_HistorySyncType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HistorySyncNotification_HistorySyncType>() {
+  return ::proto::Message_HistorySyncNotification_HistorySyncType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_InteractiveMessage_ShopMessage_Surface> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InteractiveMessage_ShopMessage_Surface>() {
+  return ::proto::Message_InteractiveMessage_ShopMessage_Surface_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_InvoiceMessage_AttachmentType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InvoiceMessage_AttachmentType>() {
+  return ::proto::Message_InvoiceMessage_AttachmentType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ListMessage_ListType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListMessage_ListType>() {
+  return ::proto::Message_ListMessage_ListType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ListResponseMessage_ListType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListResponseMessage_ListType>() {
+  return ::proto::Message_ListResponseMessage_ListType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderStatus>() {
+  return ::proto::Message_OrderMessage_OrderStatus_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderSurface> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderSurface>() {
+  return ::proto::Message_OrderMessage_OrderSurface_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_PaymentInviteMessage_ServiceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_PaymentInviteMessage_ServiceType>() {
+  return ::proto::Message_PaymentInviteMessage_ServiceType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_ProtocolMessage_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ProtocolMessage_Type>() {
+  return ::proto::Message_ProtocolMessage_Type_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_VideoMessage_Attribution> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_VideoMessage_Attribution>() {
+  return ::proto::Message_VideoMessage_Attribution_descriptor();
+}
+template <> struct is_proto_enum< ::proto::Message_RmrSource> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_RmrSource>() {
+  return ::proto::Message_RmrSource_descriptor();
+}
+template <> struct is_proto_enum< ::proto::PastParticipant_LeaveReason> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::PastParticipant_LeaveReason>() {
+  return ::proto::PastParticipant_LeaveReason_descriptor();
+}
+template <> struct is_proto_enum< ::proto::PaymentBackground_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentBackground_Type>() {
+  return ::proto::PaymentBackground_Type_descriptor();
+}
+template <> struct is_proto_enum< ::proto::PaymentInfo_Currency> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Currency>() {
+  return ::proto::PaymentInfo_Currency_descriptor();
+}
+template <> struct is_proto_enum< ::proto::PaymentInfo_Status> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Status>() {
+  return ::proto::PaymentInfo_Status_descriptor();
+}
+template <> struct is_proto_enum< ::proto::PaymentInfo_TxnStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_TxnStatus>() {
+  return ::proto::PaymentInfo_TxnStatus_descriptor();
+}
+template <> struct is_proto_enum< ::proto::SyncdMutation_SyncdOperation> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::SyncdMutation_SyncdOperation>() {
+  return ::proto::SyncdMutation_SyncdOperation_descriptor();
+}
+template <> struct is_proto_enum< ::proto::WebFeatures_Flag> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebFeatures_Flag>() {
+  return ::proto::WebFeatures_Flag_descriptor();
+}
+template <> struct is_proto_enum< ::proto::WebMessageInfo_BizPrivacyStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_BizPrivacyStatus>() {
+  return ::proto::WebMessageInfo_BizPrivacyStatus_descriptor();
+}
+template <> struct is_proto_enum< ::proto::WebMessageInfo_Status> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_Status>() {
+  return ::proto::WebMessageInfo_Status_descriptor();
+}
+template <> struct is_proto_enum< ::proto::WebMessageInfo_StubType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_StubType>() {
+  return ::proto::WebMessageInfo_StubType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::KeepType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::KeepType>() {
+  return ::proto::KeepType_descriptor();
+}
+template <> struct is_proto_enum< ::proto::MediaVisibility> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaVisibility>() {
+  return ::proto::MediaVisibility_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto
diff --git a/protocols/WhatsApp/src/pmsg.proto b/protocols/WhatsApp/src/pmsg.proto
new file mode 100644
index 0000000000..e874f35591
--- /dev/null
+++ b/protocols/WhatsApp/src/pmsg.proto
@@ -0,0 +1,2361 @@
+syntax = "proto2";
+package proto;
+
+message ADVDeviceIdentity {
+    optional uint32 rawId = 1;
+    optional uint64 timestamp = 2;
+    optional uint32 keyIndex = 3;
+}
+
+message ADVKeyIndexList {
+    optional uint32 rawId = 1;
+    optional uint64 timestamp = 2;
+    optional uint32 currentIndex = 3;
+    repeated uint32 validIndexes = 4 [packed=true];
+}
+
+message ADVSignedDeviceIdentity {
+    optional bytes details = 1;
+    optional bytes accountSignatureKey = 2;
+    optional bytes accountSignature = 3;
+    optional bytes deviceSignature = 4;
+}
+
+message ADVSignedDeviceIdentityHMAC {
+    optional bytes details = 1;
+    optional bytes hmac = 2;
+}
+
+message ADVSignedKeyIndexList {
+    optional bytes details = 1;
+    optional bytes accountSignature = 2;
+}
+
+message ActionLink {
+    optional string url = 1;
+    optional string buttonTitle = 2;
+}
+
+message AutoDownloadSettings {
+    optional bool downloadImages = 1;
+    optional bool downloadAudio = 2;
+    optional bool downloadVideo = 3;
+    optional bool downloadDocuments = 4;
+}
+
+message BizAccountLinkInfo {
+    optional uint64 whatsappBizAcctFbid = 1;
+    optional string whatsappAcctNumber = 2;
+    optional uint64 issueTime = 3;
+    optional HostStorageType hostStorage = 4;
+    optional AccountType accountType = 5;
+    enum AccountType {
+        ENTERPRISE = 0;
+    }
+    enum HostStorageType {
+        ON_PREMISE = 0;
+        FACEBOOK = 1;
+    }
+}
+
+message BizAccountPayload {
+    optional VerifiedNameCertificate vnameCert = 1;
+    optional bytes bizAcctLinkInfo = 2;
+}
+
+message BizIdentityInfo {
+    optional VerifiedLevelValue vlevel = 1;
+    optional VerifiedNameCertificate vnameCert = 2;
+    optional bool signed = 3;
+    optional bool revoked = 4;
+    optional HostStorageType hostStorage = 5;
+    optional ActualActorsType actualActors = 6;
+    optional uint64 privacyModeTs = 7;
+    optional uint64 featureControls = 8;
+    enum ActualActorsType {
+        SELF = 0;
+        BSP = 1;
+    }
+    enum HostStorageType {
+        ON_PREMISE = 0;
+        FACEBOOK = 1;
+    }
+    enum VerifiedLevelValue {
+        UNKNOWN = 0;
+        LOW = 1;
+        HIGH = 2;
+    }
+}
+
+message CertChain {
+    optional NoiseCertificate leaf = 1;
+    optional NoiseCertificate intermediate = 2;
+    message NoiseCertificate {
+        optional bytes details = 1;
+        optional bytes signature = 2;
+        message Details {
+            optional uint32 serial = 1;
+            optional uint32 issuerSerial = 2;
+            optional bytes key = 3;
+            optional uint64 notBefore = 4;
+            optional uint64 notAfter = 5;
+        }
+        
+    }
+    
+}
+
+message Chain {
+    optional bytes senderRatchetKey = 1;
+    optional bytes senderRatchetKeyPrivate = 2;
+    optional ChainKey chainKey = 3;
+    repeated MessageKey messageKeys = 4;
+}
+
+message ChainKey {
+    optional uint32 index = 1;
+    optional bytes key = 2;
+}
+
+message ClientPayload {
+    optional uint64 username = 1;
+    optional bool passive = 3;
+    optional UserAgent userAgent = 5;
+    optional WebInfo webInfo = 6;
+    optional string pushName = 7;
+    optional sfixed32 sessionId = 9;
+    optional bool shortConnect = 10;
+    optional ConnectType connectType = 12;
+    optional ConnectReason connectReason = 13;
+    repeated int32 shards = 14;
+    optional DNSSource dnsSource = 15;
+    optional uint32 connectAttemptCount = 16;
+    optional uint32 device = 18;
+    optional DevicePairingRegistrationData devicePairingData = 19;
+    optional Product product = 20;
+    optional bytes fbCat = 21;
+    optional bytes fbUserAgent = 22;
+    optional bool oc = 23;
+    optional int32 lc = 24;
+    optional IOSAppExtension iosAppExtension = 30;
+    optional uint64 fbAppId = 31;
+    optional bytes fbDeviceId = 32;
+    optional bool pull = 33;
+    optional bytes paddingBytes = 34;
+    enum ConnectReason {
+        PUSH = 0;
+        USER_ACTIVATED = 1;
+        SCHEDULED = 2;
+        ERROR_RECONNECT = 3;
+        NETWORK_SWITCH = 4;
+        PING_RECONNECT = 5;
+    }
+    enum ConnectType {
+        CELLULAR_UNKNOWN = 0;
+        WIFI_UNKNOWN = 1;
+        CELLULAR_EDGE = 100;
+        CELLULAR_IDEN = 101;
+        CELLULAR_UMTS = 102;
+        CELLULAR_EVDO = 103;
+        CELLULAR_GPRS = 104;
+        CELLULAR_HSDPA = 105;
+        CELLULAR_HSUPA = 106;
+        CELLULAR_HSPA = 107;
+        CELLULAR_CDMA = 108;
+        CELLULAR_1XRTT = 109;
+        CELLULAR_EHRPD = 110;
+        CELLULAR_LTE = 111;
+        CELLULAR_HSPAP = 112;
+    }
+    message DNSSource {
+        optional DNSResolutionMethod dnsMethod = 15;
+        optional bool appCached = 16;
+        enum DNSResolutionMethod {
+            SYSTEM = 0;
+            GOOGLE = 1;
+            HARDCODED = 2;
+            OVERRIDE = 3;
+            FALLBACK = 4;
+        }
+    }
+    
+    message DevicePairingRegistrationData {
+        optional bytes eRegid = 1;
+        optional bytes eKeytype = 2;
+        optional bytes eIdent = 3;
+        optional bytes eSkeyId = 4;
+        optional bytes eSkeyVal = 5;
+        optional bytes eSkeySig = 6;
+        optional bytes buildHash = 7;
+        optional bytes deviceProps = 8;
+    }
+    
+    enum IOSAppExtension {
+        SHARE_EXTENSION = 0;
+        SERVICE_EXTENSION = 1;
+        INTENTS_EXTENSION = 2;
+    }
+    enum Product {
+        WHATSAPP = 0;
+        MESSENGER = 1;
+    }
+    message UserAgent {
+        optional Platform platform = 1;
+        optional AppVersion appVersion = 2;
+        optional string mcc = 3;
+        optional string mnc = 4;
+        optional string osVersion = 5;
+        optional string manufacturer = 6;
+        optional string device = 7;
+        optional string osBuildNumber = 8;
+        optional string phoneId = 9;
+        optional ReleaseChannel releaseChannel = 10;
+        optional string localeLanguageIso6391 = 11;
+        optional string localeCountryIso31661Alpha2 = 12;
+        optional string deviceBoard = 13;
+        message AppVersion {
+            optional uint32 primary = 1;
+            optional uint32 secondary = 2;
+            optional uint32 tertiary = 3;
+            optional uint32 quaternary = 4;
+            optional uint32 quinary = 5;
+        }
+        
+        enum Platform {
+            ANDROID = 0;
+            IOS = 1;
+            WINDOWS_PHONE = 2;
+            BLACKBERRY = 3;
+            BLACKBERRYX = 4;
+            S40 = 5;
+            S60 = 6;
+            PYTHON_CLIENT = 7;
+            TIZEN = 8;
+            ENTERPRISE = 9;
+            SMB_ANDROID = 10;
+            KAIOS = 11;
+            SMB_IOS = 12;
+            WINDOWS = 13;
+            WEB = 14;
+            PORTAL = 15;
+            GREEN_ANDROID = 16;
+            GREEN_IPHONE = 17;
+            BLUE_ANDROID = 18;
+            BLUE_IPHONE = 19;
+            FBLITE_ANDROID = 20;
+            MLITE_ANDROID = 21;
+            IGLITE_ANDROID = 22;
+            PAGE = 23;
+            MACOS = 24;
+            OCULUS_MSG = 25;
+            OCULUS_CALL = 26;
+            MILAN = 27;
+            CAPI = 28;
+        }
+        enum ReleaseChannel {
+            RELEASE = 0;
+            BETA = 1;
+            ALPHA = 2;
+            DEBUG = 3;
+        }
+    }
+    
+    message WebInfo {
+        optional string refToken = 1;
+        optional string version = 2;
+        optional WebdPayload webdPayload = 3;
+        optional WebSubPlatform webSubPlatform = 4;
+        enum WebSubPlatform {
+            WEB_BROWSER = 0;
+            APP_STORE = 1;
+            WIN_STORE = 2;
+            DARWIN = 3;
+            WINDA = 4;
+        }
+        message WebdPayload {
+            optional bool usesParticipantInKey = 1;
+            optional bool supportsStarredMessages = 2;
+            optional bool supportsDocumentMessages = 3;
+            optional bool supportsUrlMessages = 4;
+            optional bool supportsMediaRetry = 5;
+            optional bool supportsE2EImage = 6;
+            optional bool supportsE2EVideo = 7;
+            optional bool supportsE2EAudio = 8;
+            optional bool supportsE2EDocument = 9;
+            optional string documentTypes = 10;
+            optional bytes features = 11;
+        }
+        
+    }
+    
+}
+
+message ContextInfo {
+    optional string stanzaId = 1;
+    optional string participant = 2;
+    optional Message quotedMessage = 3;
+    optional string remoteJid = 4;
+    repeated string mentionedJid = 15;
+    optional string conversionSource = 18;
+    optional bytes conversionData = 19;
+    optional uint32 conversionDelaySeconds = 20;
+    optional uint32 forwardingScore = 21;
+    optional bool isForwarded = 22;
+    optional AdReplyInfo quotedAd = 23;
+    optional MessageKey placeholderKey = 24;
+    optional uint32 expiration = 25;
+    optional int64 ephemeralSettingTimestamp = 26;
+    optional bytes ephemeralSharedSecret = 27;
+    optional ExternalAdReplyInfo externalAdReply = 28;
+    optional string entryPointConversionSource = 29;
+    optional string entryPointConversionApp = 30;
+    optional uint32 entryPointConversionDelaySeconds = 31;
+    optional DisappearingMode disappearingMode = 32;
+    optional ActionLink actionLink = 33;
+    optional string groupSubject = 34;
+    optional string parentGroupJid = 35;
+    message AdReplyInfo {
+        optional string advertiserName = 1;
+        optional MediaType mediaType = 2;
+        optional bytes jpegThumbnail = 16;
+        optional string caption = 17;
+        enum MediaType {
+            NONE = 0;
+            IMAGE = 1;
+            VIDEO = 2;
+        }
+    }
+    
+    message ExternalAdReplyInfo {
+        optional string title = 1;
+        optional string body = 2;
+        optional MediaType mediaType = 3;
+        optional string thumbnailUrl = 4;
+        optional string mediaUrl = 5;
+        optional bytes thumbnail = 6;
+        optional string sourceType = 7;
+        optional string sourceId = 8;
+        optional string sourceUrl = 9;
+        optional bool containsAutoReply = 10;
+        optional bool renderLargerThumbnail = 11;
+        optional bool showAdAttribution = 12;
+        enum MediaType {
+            NONE = 0;
+            IMAGE = 1;
+            VIDEO = 2;
+        }
+    }
+    
+}
+
+message Conversation {
+    required string id = 1;
+    repeated HistorySyncMsg messages = 2;
+    optional string newJid = 3;
+    optional string oldJid = 4;
+    optional uint64 lastMsgTimestamp = 5;
+    optional uint32 unreadCount = 6;
+    optional bool readOnly = 7;
+    optional bool endOfHistoryTransfer = 8;
+    optional uint32 ephemeralExpiration = 9;
+    optional int64 ephemeralSettingTimestamp = 10;
+    optional EndOfHistoryTransferType endOfHistoryTransferType = 11;
+    optional uint64 conversationTimestamp = 12;
+    optional string name = 13;
+    optional string pHash = 14;
+    optional bool notSpam = 15;
+    optional bool archived = 16;
+    optional DisappearingMode disappearingMode = 17;
+    optional uint32 unreadMentionCount = 18;
+    optional bool markedAsUnread = 19;
+    repeated GroupParticipant participant = 20;
+    optional bytes tcToken = 21;
+    optional uint64 tcTokenTimestamp = 22;
+    optional bytes contactPrimaryIdentityKey = 23;
+    optional uint32 pinned = 24;
+    optional uint64 muteEndTime = 25;
+    optional WallpaperSettings wallpaper = 26;
+    optional MediaVisibility mediaVisibility = 27;
+    optional uint64 tcTokenSenderTimestamp = 28;
+    optional bool suspended = 29;
+    optional bool terminated = 30;
+    optional uint64 createdAt = 31;
+    optional string createdBy = 32;
+    optional string description = 33;
+    optional bool support = 34;
+    optional bool isParentGroup = 35;
+    optional bool isDefaultSubgroup = 36;
+    optional string parentGroupId = 37;
+    optional string displayName = 38;
+    optional string pnJid = 39;
+    optional bool selfPnExposed = 40;
+    enum EndOfHistoryTransferType {
+        COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0;
+        COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1;
+    }
+}
+
+message DeviceListMetadata {
+    optional bytes senderKeyHash = 1;
+    optional uint64 senderTimestamp = 2;
+    repeated uint32 senderKeyIndexes = 3 [packed=true];
+    optional bytes recipientKeyHash = 8;
+    optional uint64 recipientTimestamp = 9;
+    repeated uint32 recipientKeyIndexes = 10 [packed=true];
+}
+
+message DeviceProps {
+    optional string os = 1;
+    optional AppVersion version = 2;
+    optional PlatformType platformType = 3;
+    optional bool requireFullSync = 4;
+    message AppVersion {
+        optional uint32 primary = 1;
+        optional uint32 secondary = 2;
+        optional uint32 tertiary = 3;
+        optional uint32 quaternary = 4;
+        optional uint32 quinary = 5;
+    }
+    
+    enum PlatformType {
+        UNKNOWN = 0;
+        CHROME = 1;
+        FIREFOX = 2;
+        IE = 3;
+        OPERA = 4;
+        SAFARI = 5;
+        EDGE = 6;
+        DESKTOP = 7;
+        IPAD = 8;
+        ANDROID_TABLET = 9;
+        OHANA = 10;
+        ALOHA = 11;
+        CATALINA = 12;
+        TCL_TV = 13;
+    }
+}
+
+message DisappearingMode {
+    optional Initiator initiator = 1;
+    enum Initiator {
+        CHANGED_IN_CHAT = 0;
+        INITIATED_BY_ME = 1;
+        INITIATED_BY_OTHER = 2;
+    }
+}
+
+message EphemeralSetting {
+    optional sfixed32 duration = 1;
+    optional sfixed64 timestamp = 2;
+}
+
+message ExitCode {
+    optional uint64 code = 1;
+    optional string text = 2;
+}
+
+message ExternalBlobReference {
+    optional bytes mediaKey = 1;
+    optional string directPath = 2;
+    optional string handle = 3;
+    optional uint64 fileSizeBytes = 4;
+    optional bytes fileSha256 = 5;
+    optional bytes fileEncSha256 = 6;
+}
+
+message GlobalSettings {
+    optional WallpaperSettings lightThemeWallpaper = 1;
+    optional MediaVisibility mediaVisibility = 2;
+    optional WallpaperSettings darkThemeWallpaper = 3;
+    optional AutoDownloadSettings autoDownloadWiFi = 4;
+    optional AutoDownloadSettings autoDownloadCellular = 5;
+    optional AutoDownloadSettings autoDownloadRoaming = 6;
+    optional bool showIndividualNotificationsPreview = 7;
+    optional bool showGroupNotificationsPreview = 8;
+    optional int32 disappearingModeDuration = 9;
+    optional int64 disappearingModeTimestamp = 10;
+}
+
+message GroupParticipant {
+    required string userJid = 1;
+    optional Rank rank = 2;
+    enum Rank {
+        REGULAR = 0;
+        ADMIN = 1;
+        SUPERADMIN = 2;
+    }
+}
+
+message HandshakeMessage {
+    optional ClientHello clientHello = 2;
+    optional ServerHello serverHello = 3;
+    optional ClientFinish clientFinish = 4;
+    message ClientFinish {
+        optional bytes static = 1;
+        optional bytes payload = 2;
+    }
+    
+    message ClientHello {
+        optional bytes ephemeral = 1;
+        optional bytes static = 2;
+        optional bytes payload = 3;
+    }
+    
+    message ServerHello {
+        optional bytes ephemeral = 1;
+        optional bytes static = 2;
+        optional bytes payload = 3;
+    }
+    
+}
+
+message HistorySync {
+    required HistorySyncType syncType = 1;
+    repeated Conversation conversations = 2;
+    repeated WebMessageInfo statusV3Messages = 3;
+    optional uint32 chunkOrder = 5;
+    optional uint32 progress = 6;
+    repeated Pushname pushnames = 7;
+    optional GlobalSettings globalSettings = 8;
+    optional bytes threadIdUserSecret = 9;
+    optional uint32 threadDsTimeframeOffset = 10;
+    repeated StickerMetadata recentStickers = 11;
+    repeated PastParticipants pastParticipants = 12;
+    enum HistorySyncType {
+        INITIAL_BOOTSTRAP = 0;
+        INITIAL_STATUS_V3 = 1;
+        FULL = 2;
+        RECENT = 3;
+        PUSH_NAME = 4;
+        UNBLOCKING_DATA = 5;
+    }
+}
+
+message HistorySyncMsg {
+    optional WebMessageInfo message = 1;
+    optional uint64 msgOrderId = 2;
+}
+
+message HydratedTemplateButton {
+    optional uint32 index = 4;
+    oneof hydratedButton {
+        HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
+        HydratedTemplateButton.HydratedURLButton urlButton = 2;
+        HydratedTemplateButton.HydratedCallButton callButton = 3;
+    }
+    message HydratedCallButton {
+        optional string displayText = 1;
+        optional string phoneNumber = 2;
+    }
+    
+    message HydratedQuickReplyButton {
+        optional string displayText = 1;
+        optional string id = 2;
+    }
+    
+    message HydratedURLButton {
+        optional string displayText = 1;
+        optional string url = 2;
+    }
+    
+}
+
+message IdentityKeyPairStructure {
+    optional bytes publicKey = 1;
+    optional bytes privateKey = 2;
+}
+
+message InteractiveAnnotation {
+    repeated Point polygonVertices = 1;
+    oneof action {
+        Location location = 2;
+    }
+}
+
+message KeepInChat {
+    optional KeepType keepType = 1;
+    optional int64 serverTimestamp = 2;
+    optional MessageKey key = 3;
+    optional string deviceJid = 4;
+}
+
+enum KeepType {
+    UNKNOWN = 0;
+    KEEP_FOR_ALL = 1;
+    UNDO_KEEP_FOR_ALL = 2;
+}
+message KeyId {
+    optional bytes id = 1;
+}
+
+message LocalizedName {
+    optional string lg = 1;
+    optional string lc = 2;
+    optional string verifiedName = 3;
+}
+
+message Location {
+    optional double degreesLatitude = 1;
+    optional double degreesLongitude = 2;
+    optional string name = 3;
+}
+
+message MediaData {
+    optional string localPath = 1;
+}
+
+message MediaRetryNotification {
+    optional string stanzaId = 1;
+    optional string directPath = 2;
+    optional ResultType result = 3;
+    enum ResultType {
+        GENERAL_ERROR = 0;
+        SUCCESS = 1;
+        NOT_FOUND = 2;
+        DECRYPTION_ERROR = 3;
+    }
+}
+
+enum MediaVisibility {
+    DEFAULT = 0;
+    OFF = 1;
+    ON = 2;
+}
+message Message {
+    optional string conversation = 1;
+    optional SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+    optional ImageMessage imageMessage = 3;
+    optional ContactMessage contactMessage = 4;
+    optional LocationMessage locationMessage = 5;
+    optional ExtendedTextMessage extendedTextMessage = 6;
+    optional DocumentMessage documentMessage = 7;
+    optional AudioMessage audioMessage = 8;
+    optional VideoMessage videoMessage = 9;
+    optional Call call = 10;
+    optional Chat chat = 11;
+    optional ProtocolMessage protocolMessage = 12;
+    optional ContactsArrayMessage contactsArrayMessage = 13;
+    optional HighlyStructuredMessage highlyStructuredMessage = 14;
+    optional SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+    optional SendPaymentMessage sendPaymentMessage = 16;
+    optional LiveLocationMessage liveLocationMessage = 18;
+    optional RequestPaymentMessage requestPaymentMessage = 22;
+    optional DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
+    optional CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
+    optional TemplateMessage templateMessage = 25;
+    optional StickerMessage stickerMessage = 26;
+    optional GroupInviteMessage groupInviteMessage = 28;
+    optional TemplateButtonReplyMessage templateButtonReplyMessage = 29;
+    optional ProductMessage productMessage = 30;
+    optional DeviceSentMessage deviceSentMessage = 31;
+    optional MessageContextInfo messageContextInfo = 35;
+    optional ListMessage listMessage = 36;
+    optional FutureProofMessage viewOnceMessage = 37;
+    optional OrderMessage orderMessage = 38;
+    optional ListResponseMessage listResponseMessage = 39;
+    optional FutureProofMessage ephemeralMessage = 40;
+    optional InvoiceMessage invoiceMessage = 41;
+    optional ButtonsMessage buttonsMessage = 42;
+    optional ButtonsResponseMessage buttonsResponseMessage = 43;
+    optional PaymentInviteMessage paymentInviteMessage = 44;
+    optional InteractiveMessage interactiveMessage = 45;
+    optional ReactionMessage reactionMessage = 46;
+    optional StickerSyncRMRMessage stickerSyncRmrMessage = 47;
+    optional InteractiveResponseMessage interactiveResponseMessage = 48;
+    optional PollCreationMessage pollCreationMessage = 49;
+    optional PollUpdateMessage pollUpdateMessage = 50;
+    optional KeepInChatMessage keepInChatMessage = 51;
+    optional FutureProofMessage documentWithCaptionMessage = 53;
+    optional RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
+    optional FutureProofMessage viewOnceMessageV2 = 55;
+    message AppStateFatalExceptionNotification {
+        repeated string collectionNames = 1;
+        optional int64 timestamp = 2;
+    }
+    
+    message AppStateSyncKeyData {
+        optional bytes keyData = 1;
+        optional Message.AppStateSyncKeyFingerprint fingerprint = 2;
+        optional int64 timestamp = 3;
+    }
+    
+    message AppStateSyncKeyFingerprint {
+        optional uint32 rawId = 1;
+        optional uint32 currentIndex = 2;
+        repeated uint32 deviceIndexes = 3 [packed=true];
+    }
+    
+    message AppStateSyncKeyId {
+        optional bytes keyId = 1;
+    }
+    
+    message AppStateSyncKeyRequest {
+        repeated Message.AppStateSyncKeyId keyIds = 1;
+    }
+    
+    message AppStateSyncKeyShare {
+        repeated Message.AppStateSyncKey keys = 1;
+    }
+    
+    message AppStateSyncKey {
+        optional Message.AppStateSyncKeyId keyId = 1;
+        optional Message.AppStateSyncKeyData keyData = 2;
+    }
+    
+    message AudioMessage {
+        optional string url = 1;
+        optional string mimetype = 2;
+        optional bytes fileSha256 = 3;
+        optional uint64 fileLength = 4;
+        optional uint32 seconds = 5;
+        optional bool ptt = 6;
+        optional bytes mediaKey = 7;
+        optional bytes fileEncSha256 = 8;
+        optional string directPath = 9;
+        optional int64 mediaKeyTimestamp = 10;
+        optional ContextInfo contextInfo = 17;
+        optional bytes streamingSidecar = 18;
+        optional bytes waveform = 19;
+    }
+    
+    message ButtonsMessage {
+        optional string contentText = 6;
+        optional string footerText = 7;
+        optional ContextInfo contextInfo = 8;
+        repeated Button buttons = 9;
+        optional HeaderType headerType = 10;
+        oneof header {
+            string text = 1;
+            Message.DocumentMessage documentMessage = 2;
+            Message.ImageMessage imageMessage = 3;
+            Message.VideoMessage videoMessage = 4;
+            Message.LocationMessage locationMessage = 5;
+        }
+        message Button {
+            optional string buttonId = 1;
+            optional ButtonText buttonText = 2;
+            optional Type type = 3;
+            optional NativeFlowInfo nativeFlowInfo = 4;
+            message ButtonText {
+                optional string displayText = 1;
+            }
+            
+            message NativeFlowInfo {
+                optional string name = 1;
+                optional string paramsJson = 2;
+            }
+            
+            enum Type {
+                UNKNOWN = 0;
+                RESPONSE = 1;
+                NATIVE_FLOW = 2;
+            }
+        }
+        
+        enum HeaderType {
+            UNKNOWN = 0;
+            EMPTY = 1;
+            TEXT = 2;
+            DOCUMENT = 3;
+            IMAGE = 4;
+            VIDEO = 5;
+            LOCATION = 6;
+        }
+    }
+    
+    message ButtonsResponseMessage {
+        optional string selectedButtonId = 1;
+        optional ContextInfo contextInfo = 3;
+        optional Type type = 4;
+        oneof response {
+            string selectedDisplayText = 2;
+        }
+        enum Type {
+            UNKNOWN = 0;
+            DISPLAY_TEXT = 1;
+        }
+    }
+    
+    message Call {
+        optional bytes callKey = 1;
+        optional string conversionSource = 2;
+        optional bytes conversionData = 3;
+        optional uint32 conversionDelaySeconds = 4;
+    }
+    
+    message CancelPaymentRequestMessage {
+        optional MessageKey key = 1;
+    }
+    
+    message Chat {
+        optional string displayName = 1;
+        optional string id = 2;
+    }
+    
+    message ContactMessage {
+        optional string displayName = 1;
+        optional string vcard = 16;
+        optional ContextInfo contextInfo = 17;
+    }
+    
+    message ContactsArrayMessage {
+        optional string displayName = 1;
+        repeated Message.ContactMessage contacts = 2;
+        optional ContextInfo contextInfo = 17;
+    }
+    
+    message DeclinePaymentRequestMessage {
+        optional MessageKey key = 1;
+    }
+    
+    message DeviceSentMessage {
+        optional string destinationJid = 1;
+        optional Message message = 2;
+        optional string phash = 3;
+    }
+    
+    message DocumentMessage {
+        optional string url = 1;
+        optional string mimetype = 2;
+        optional string title = 3;
+        optional bytes fileSha256 = 4;
+        optional uint64 fileLength = 5;
+        optional uint32 pageCount = 6;
+        optional bytes mediaKey = 7;
+        optional string fileName = 8;
+        optional bytes fileEncSha256 = 9;
+        optional string directPath = 10;
+        optional int64 mediaKeyTimestamp = 11;
+        optional bool contactVcard = 12;
+        optional string thumbnailDirectPath = 13;
+        optional bytes thumbnailSha256 = 14;
+        optional bytes thumbnailEncSha256 = 15;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+        optional uint32 thumbnailHeight = 18;
+        optional uint32 thumbnailWidth = 19;
+        optional string caption = 20;
+    }
+    
+    message ExtendedTextMessage {
+        optional string text = 1;
+        optional string matchedText = 2;
+        optional string canonicalUrl = 4;
+        optional string description = 5;
+        optional string title = 6;
+        optional fixed32 textArgb = 7;
+        optional fixed32 backgroundArgb = 8;
+        optional FontType font = 9;
+        optional PreviewType previewType = 10;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+        optional bool doNotPlayInline = 18;
+        optional string thumbnailDirectPath = 19;
+        optional bytes thumbnailSha256 = 20;
+        optional bytes thumbnailEncSha256 = 21;
+        optional bytes mediaKey = 22;
+        optional int64 mediaKeyTimestamp = 23;
+        optional uint32 thumbnailHeight = 24;
+        optional uint32 thumbnailWidth = 25;
+        optional InviteLinkGroupType inviteLinkGroupType = 26;
+        optional string inviteLinkParentGroupSubjectV2 = 27;
+        optional bytes inviteLinkParentGroupThumbnailV2 = 28;
+        optional InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
+        enum FontType {
+            SANS_SERIF = 0;
+            SERIF = 1;
+            NORICAN_REGULAR = 2;
+            BRYNDAN_WRITE = 3;
+            BEBASNEUE_REGULAR = 4;
+            OSWALD_HEAVY = 5;
+        }
+        enum InviteLinkGroupType {
+            DEFAULT = 0;
+            PARENT = 1;
+            SUB = 2;
+            DEFAULT_SUB = 3;
+        }
+        enum PreviewType {
+            NONE = 0;
+            VIDEO = 1;
+        }
+    }
+    
+    message FutureProofMessage {
+        optional Message message = 1;
+    }
+    
+    message GroupInviteMessage {
+        optional string groupJid = 1;
+        optional string inviteCode = 2;
+        optional int64 inviteExpiration = 3;
+        optional string groupName = 4;
+        optional bytes jpegThumbnail = 5;
+        optional string caption = 6;
+        optional ContextInfo contextInfo = 7;
+        optional GroupType groupType = 8;
+        enum GroupType {
+            DEFAULT = 0;
+            PARENT = 1;
+        }
+    }
+    
+    message HighlyStructuredMessage {
+        optional string namespace = 1;
+        optional string elementName = 2;
+        repeated string params = 3;
+        optional string fallbackLg = 4;
+        optional string fallbackLc = 5;
+        repeated HSMLocalizableParameter localizableParams = 6;
+        optional string deterministicLg = 7;
+        optional string deterministicLc = 8;
+        optional Message.TemplateMessage hydratedHsm = 9;
+        message HSMLocalizableParameter {
+            optional string default = 1;
+            oneof paramOneof {
+                Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
+                Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
+            }
+            message HSMCurrency {
+                optional string currencyCode = 1;
+                optional int64 amount1000 = 2;
+            }
+            
+            message HSMDateTime {
+                oneof datetimeOneof {
+                    Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
+                    Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
+                }
+                message HSMDateTimeComponent {
+                    optional DayOfWeekType dayOfWeek = 1;
+                    optional uint32 year = 2;
+                    optional uint32 month = 3;
+                    optional uint32 dayOfMonth = 4;
+                    optional uint32 hour = 5;
+                    optional uint32 minute = 6;
+                    optional CalendarType calendar = 7;
+                    enum CalendarType {
+                        GREGORIAN = 1;
+                        SOLAR_HIJRI = 2;
+                    }
+                    enum DayOfWeekType {
+                        MONDAY = 1;
+                        TUESDAY = 2;
+                        WEDNESDAY = 3;
+                        THURSDAY = 4;
+                        FRIDAY = 5;
+                        SATURDAY = 6;
+                        SUNDAY = 7;
+                    }
+                }
+                
+                message HSMDateTimeUnixEpoch {
+                    optional int64 timestamp = 1;
+                }
+                
+            }
+            
+        }
+        
+    }
+    
+    message HistorySyncNotification {
+        optional bytes fileSha256 = 1;
+        optional uint64 fileLength = 2;
+        optional bytes mediaKey = 3;
+        optional bytes fileEncSha256 = 4;
+        optional string directPath = 5;
+        optional HistorySyncType syncType = 6;
+        optional uint32 chunkOrder = 7;
+        optional string originalMessageId = 8;
+        optional uint32 progress = 9;
+        enum HistorySyncType {
+            INITIAL_BOOTSTRAP = 0;
+            INITIAL_STATUS_V3 = 1;
+            FULL = 2;
+            RECENT = 3;
+            PUSH_NAME = 4;
+        }
+    }
+    
+    message ImageMessage {
+        optional string url = 1;
+        optional string mimetype = 2;
+        optional string caption = 3;
+        optional bytes fileSha256 = 4;
+        optional uint64 fileLength = 5;
+        optional uint32 height = 6;
+        optional uint32 width = 7;
+        optional bytes mediaKey = 8;
+        optional bytes fileEncSha256 = 9;
+        repeated InteractiveAnnotation interactiveAnnotations = 10;
+        optional string directPath = 11;
+        optional int64 mediaKeyTimestamp = 12;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+        optional bytes firstScanSidecar = 18;
+        optional uint32 firstScanLength = 19;
+        optional uint32 experimentGroupId = 20;
+        optional bytes scansSidecar = 21;
+        repeated uint32 scanLengths = 22;
+        optional bytes midQualityFileSha256 = 23;
+        optional bytes midQualityFileEncSha256 = 24;
+        optional bool viewOnce = 25;
+        optional string thumbnailDirectPath = 26;
+        optional bytes thumbnailSha256 = 27;
+        optional bytes thumbnailEncSha256 = 28;
+        optional string staticUrl = 29;
+    }
+    
+    message InitialSecurityNotificationSettingSync {
+        optional bool securityNotificationEnabled = 1;
+    }
+    
+    message InteractiveMessage {
+        optional Header header = 1;
+        optional Body body = 2;
+        optional Footer footer = 3;
+        optional ContextInfo contextInfo = 15;
+        oneof interactiveMessage {
+            Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
+            Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
+            Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
+        }
+        message Body {
+            optional string text = 1;
+        }
+        
+        message CollectionMessage {
+            optional string bizJid = 1;
+            optional string id = 2;
+            optional int32 messageVersion = 3;
+        }
+        
+        message Footer {
+            optional string text = 1;
+        }
+        
+        message Header {
+            optional string title = 1;
+            optional string subtitle = 2;
+            optional bool hasMediaAttachment = 5;
+            oneof media {
+                Message.DocumentMessage documentMessage = 3;
+                Message.ImageMessage imageMessage = 4;
+                bytes jpegThumbnail = 6;
+                Message.VideoMessage videoMessage = 7;
+            }
+        }
+        
+        message NativeFlowMessage {
+            repeated NativeFlowButton buttons = 1;
+            optional string messageParamsJson = 2;
+            optional int32 messageVersion = 3;
+            message NativeFlowButton {
+                optional string name = 1;
+                optional string buttonParamsJson = 2;
+            }
+            
+        }
+        
+        message ShopMessage {
+            optional string id = 1;
+            optional Surface surface = 2;
+            optional int32 messageVersion = 3;
+            enum Surface {
+                UNKNOWN_SURFACE = 0;
+                FB = 1;
+                IG = 2;
+                WA = 3;
+            }
+        }
+        
+    }
+    
+    message InteractiveResponseMessage {
+        optional Body body = 1;
+        optional ContextInfo contextInfo = 15;
+        oneof interactiveResponseMessage {
+            Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
+        }
+        message Body {
+            optional string text = 1;
+        }
+        
+        message NativeFlowResponseMessage {
+            optional string name = 1;
+            optional string paramsJson = 2;
+            optional int32 version = 3;
+        }
+        
+    }
+    
+    message InvoiceMessage {
+        optional string note = 1;
+        optional string token = 2;
+        optional AttachmentType attachmentType = 3;
+        optional string attachmentMimetype = 4;
+        optional bytes attachmentMediaKey = 5;
+        optional int64 attachmentMediaKeyTimestamp = 6;
+        optional bytes attachmentFileSha256 = 7;
+        optional bytes attachmentFileEncSha256 = 8;
+        optional string attachmentDirectPath = 9;
+        optional bytes attachmentJpegThumbnail = 10;
+        enum AttachmentType {
+            IMAGE = 0;
+            PDF = 1;
+        }
+    }
+    
+    message KeepInChatMessage {
+        optional MessageKey key = 1;
+        optional KeepType keepType = 2;
+        optional int64 timestampMs = 3;
+    }
+    
+    message ListMessage {
+        optional string title = 1;
+        optional string description = 2;
+        optional string buttonText = 3;
+        optional ListType listType = 4;
+        repeated Section sections = 5;
+        optional ProductListInfo productListInfo = 6;
+        optional string footerText = 7;
+        optional ContextInfo contextInfo = 8;
+        enum ListType {
+            UNKNOWN = 0;
+            SINGLE_SELECT = 1;
+            PRODUCT_LIST = 2;
+        }
+        message ProductListHeaderImage {
+            optional string productId = 1;
+            optional bytes jpegThumbnail = 2;
+        }
+        
+        message ProductListInfo {
+            repeated Message.ListMessage.ProductSection productSections = 1;
+            optional Message.ListMessage.ProductListHeaderImage headerImage = 2;
+            optional string businessOwnerJid = 3;
+        }
+        
+        message ProductSection {
+            optional string title = 1;
+            repeated Message.ListMessage.Product products = 2;
+        }
+        
+        message Product {
+            optional string productId = 1;
+        }
+        
+        message Row {
+            optional string title = 1;
+            optional string description = 2;
+            optional string rowId = 3;
+        }
+        
+        message Section {
+            optional string title = 1;
+            repeated Message.ListMessage.Row rows = 2;
+        }
+        
+    }
+    
+    message ListResponseMessage {
+        optional string title = 1;
+        optional ListType listType = 2;
+        optional SingleSelectReply singleSelectReply = 3;
+        optional ContextInfo contextInfo = 4;
+        optional string description = 5;
+        enum ListType {
+            UNKNOWN = 0;
+            SINGLE_SELECT = 1;
+        }
+        message SingleSelectReply {
+            optional string selectedRowId = 1;
+        }
+        
+    }
+    
+    message LiveLocationMessage {
+        optional double degreesLatitude = 1;
+        optional double degreesLongitude = 2;
+        optional uint32 accuracyInMeters = 3;
+        optional float speedInMps = 4;
+        optional uint32 degreesClockwiseFromMagneticNorth = 5;
+        optional string caption = 6;
+        optional int64 sequenceNumber = 7;
+        optional uint32 timeOffset = 8;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+    }
+    
+    message LocationMessage {
+        optional double degreesLatitude = 1;
+        optional double degreesLongitude = 2;
+        optional string name = 3;
+        optional string address = 4;
+        optional string url = 5;
+        optional bool isLive = 6;
+        optional uint32 accuracyInMeters = 7;
+        optional float speedInMps = 8;
+        optional uint32 degreesClockwiseFromMagneticNorth = 9;
+        optional string comment = 11;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+    }
+    
+    message OrderMessage {
+        optional string orderId = 1;
+        optional bytes thumbnail = 2;
+        optional int32 itemCount = 3;
+        optional OrderStatus status = 4;
+        optional OrderSurface surface = 5;
+        optional string message = 6;
+        optional string orderTitle = 7;
+        optional string sellerJid = 8;
+        optional string token = 9;
+        optional int64 totalAmount1000 = 10;
+        optional string totalCurrencyCode = 11;
+        optional ContextInfo contextInfo = 17;
+        enum OrderStatus {
+            INQUIRY = 1;
+        }
+        enum OrderSurface {
+            CATALOG = 1;
+        }
+    }
+    
+    message PaymentInviteMessage {
+        optional ServiceType serviceType = 1;
+        optional int64 expiryTimestamp = 2;
+        enum ServiceType {
+            UNKNOWN = 0;
+            FBPAY = 1;
+            NOVI = 2;
+            UPI = 3;
+        }
+    }
+    
+    message PollCreationMessage {
+        optional bytes encKey = 1;
+        optional string name = 2;
+        repeated Option options = 3;
+        optional uint32 selectableOptionsCount = 4;
+        optional ContextInfo contextInfo = 5;
+        message Option {
+            optional string optionName = 1;
+        }
+        
+    }
+    
+    message PollEncValue {
+        optional bytes encPayload = 1;
+        optional bytes encIv = 2;
+    }
+    
+    message PollUpdateMessageMetadata {
+    }
+    
+    message PollUpdateMessage {
+        optional MessageKey pollCreationMessageKey = 1;
+        optional Message.PollEncValue vote = 2;
+        optional Message.PollUpdateMessageMetadata metadata = 3;
+        optional int64 senderTimestampMs = 4;
+    }
+    
+    message PollVoteMessage {
+        repeated bytes selectedOptions = 1;
+    }
+    
+    message ProductMessage {
+        optional ProductSnapshot product = 1;
+        optional string businessOwnerJid = 2;
+        optional CatalogSnapshot catalog = 4;
+        optional string body = 5;
+        optional string footer = 6;
+        optional ContextInfo contextInfo = 17;
+        message CatalogSnapshot {
+            optional Message.ImageMessage catalogImage = 1;
+            optional string title = 2;
+            optional string description = 3;
+        }
+        
+        message ProductSnapshot {
+            optional Message.ImageMessage productImage = 1;
+            optional string productId = 2;
+            optional string title = 3;
+            optional string description = 4;
+            optional string currencyCode = 5;
+            optional int64 priceAmount1000 = 6;
+            optional string retailerId = 7;
+            optional string url = 8;
+            optional uint32 productImageCount = 9;
+            optional string firstImageId = 11;
+            optional int64 salePriceAmount1000 = 12;
+        }
+        
+    }
+    
+    message ProtocolMessage {
+        optional MessageKey key = 1;
+        optional Type type = 2;
+        optional uint32 ephemeralExpiration = 4;
+        optional int64 ephemeralSettingTimestamp = 5;
+        optional Message.HistorySyncNotification historySyncNotification = 6;
+        optional Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
+        optional Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
+        optional Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
+        optional Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
+        optional DisappearingMode disappearingMode = 11;
+        optional Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
+        optional Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
+        enum Type {
+            REVOKE = 0;
+            EPHEMERAL_SETTING = 3;
+            EPHEMERAL_SYNC_RESPONSE = 4;
+            HISTORY_SYNC_NOTIFICATION = 5;
+            APP_STATE_SYNC_KEY_SHARE = 6;
+            APP_STATE_SYNC_KEY_REQUEST = 7;
+            MSG_FANOUT_BACKFILL_REQUEST = 8;
+            INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9;
+            APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10;
+            SHARE_PHONE_NUMBER = 11;
+            REQUEST_MEDIA_UPLOAD_MESSAGE = 12;
+            REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13;
+        }
+    }
+    
+    message ReactionMessage {
+        optional MessageKey key = 1;
+        optional string text = 2;
+        optional string groupingKey = 3;
+        optional int64 senderTimestampMs = 4;
+    }
+    
+    message RequestMediaUploadMessage {
+        repeated string fileSha256 = 1;
+        optional Message.RmrSource rmrSource = 2;
+    }
+    
+    message RequestMediaUploadResponseMessage {
+        optional Message.RmrSource rmrSource = 1;
+        optional string stanzaId = 2;
+        repeated RequestMediaUploadResult reuploadResult = 3;
+        message RequestMediaUploadResult {
+            optional string fileSha256 = 1;
+            optional MediaRetryNotification.ResultType mediaUploadResult = 2;
+            optional Message.StickerMessage stickerMessage = 3;
+        }
+        
+    }
+    
+    message RequestPaymentMessage {
+        optional Message noteMessage = 4;
+        optional string currencyCodeIso4217 = 1;
+        optional uint64 amount1000 = 2;
+        optional string requestFrom = 3;
+        optional int64 expiryTimestamp = 5;
+        optional Money amount = 6;
+        optional PaymentBackground background = 7;
+    }
+    
+    message RequestPhoneNumberMessage {
+        optional ContextInfo contextInfo = 1;
+    }
+    
+    enum RmrSource {
+        FAVORITE_STICKER = 0;
+        RECENT_STICKER = 1;
+    }
+    message SendPaymentMessage {
+        optional Message noteMessage = 2;
+        optional MessageKey requestMessageKey = 3;
+        optional PaymentBackground background = 4;
+    }
+    
+    message SenderKeyDistributionMessage {
+        optional string groupId = 1;
+        optional bytes axolotlSenderKeyDistributionMessage = 2;
+    }
+    
+    message StickerMessage {
+        optional string url = 1;
+        optional bytes fileSha256 = 2;
+        optional bytes fileEncSha256 = 3;
+        optional bytes mediaKey = 4;
+        optional string mimetype = 5;
+        optional uint32 height = 6;
+        optional uint32 width = 7;
+        optional string directPath = 8;
+        optional uint64 fileLength = 9;
+        optional int64 mediaKeyTimestamp = 10;
+        optional uint32 firstFrameLength = 11;
+        optional bytes firstFrameSidecar = 12;
+        optional bool isAnimated = 13;
+        optional bytes pngThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+    }
+    
+    message StickerSyncRMRMessage {
+        repeated string filehash = 1;
+        optional string rmrSource = 2;
+        optional int64 requestTimestamp = 3;
+    }
+    
+    message TemplateButtonReplyMessage {
+        optional string selectedId = 1;
+        optional string selectedDisplayText = 2;
+        optional ContextInfo contextInfo = 3;
+        optional uint32 selectedIndex = 4;
+    }
+    
+    message TemplateMessage {
+        optional ContextInfo contextInfo = 3;
+        optional HydratedFourRowTemplate hydratedTemplate = 4;
+        oneof format {
+            Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
+            Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
+        }
+        message FourRowTemplate {
+            optional Message.HighlyStructuredMessage content = 6;
+            optional Message.HighlyStructuredMessage footer = 7;
+            repeated TemplateButton buttons = 8;
+            oneof title {
+                Message.DocumentMessage documentMessage = 1;
+                Message.HighlyStructuredMessage highlyStructuredMessage = 2;
+                Message.ImageMessage imageMessage = 3;
+                Message.VideoMessage videoMessage = 4;
+                Message.LocationMessage locationMessage = 5;
+            }
+        }
+        
+        message HydratedFourRowTemplate {
+            optional string hydratedContentText = 6;
+            optional string hydratedFooterText = 7;
+            repeated HydratedTemplateButton hydratedButtons = 8;
+            optional string templateId = 9;
+            oneof title {
+                Message.DocumentMessage documentMessage = 1;
+                string hydratedTitleText = 2;
+                Message.ImageMessage imageMessage = 3;
+                Message.VideoMessage videoMessage = 4;
+                Message.LocationMessage locationMessage = 5;
+            }
+        }
+        
+    }
+    
+    message VideoMessage {
+        optional string url = 1;
+        optional string mimetype = 2;
+        optional bytes fileSha256 = 3;
+        optional uint64 fileLength = 4;
+        optional uint32 seconds = 5;
+        optional bytes mediaKey = 6;
+        optional string caption = 7;
+        optional bool gifPlayback = 8;
+        optional uint32 height = 9;
+        optional uint32 width = 10;
+        optional bytes fileEncSha256 = 11;
+        repeated InteractiveAnnotation interactiveAnnotations = 12;
+        optional string directPath = 13;
+        optional int64 mediaKeyTimestamp = 14;
+        optional bytes jpegThumbnail = 16;
+        optional ContextInfo contextInfo = 17;
+        optional bytes streamingSidecar = 18;
+        optional Attribution gifAttribution = 19;
+        optional bool viewOnce = 20;
+        optional string thumbnailDirectPath = 21;
+        optional bytes thumbnailSha256 = 22;
+        optional bytes thumbnailEncSha256 = 23;
+        optional string staticUrl = 24;
+        enum Attribution {
+            NONE = 0;
+            GIPHY = 1;
+            TENOR = 2;
+        }
+    }
+    
+}
+
+message MessageContextInfo {
+    optional DeviceListMetadata deviceListMetadata = 1;
+    optional int32 deviceListMetadataVersion = 2;
+    optional bytes messageSecret = 3;
+    optional bytes paddingBytes = 4;
+}
+
+message MessageKey {
+    optional string remoteJid = 1;
+    optional bool fromMe = 2;
+    optional string id = 3;
+    optional string participant = 4;
+}
+
+message Money {
+    optional int64 value = 1;
+    optional uint32 offset = 2;
+    optional string currencyCode = 3;
+}
+
+message MsgOpaqueData {
+    optional string body = 1;
+    optional string caption = 3;
+    optional double lng = 5;
+    optional bool isLive = 6;
+    optional double lat = 7;
+    optional int32 paymentAmount1000 = 8;
+    optional string paymentNoteMsgBody = 9;
+    optional string canonicalUrl = 10;
+    optional string matchedText = 11;
+    optional string title = 12;
+    optional string description = 13;
+    optional bytes futureproofBuffer = 14;
+    optional string clientUrl = 15;
+    optional string loc = 16;
+    optional string pollName = 17;
+    repeated PollOption pollOptions = 18;
+    optional uint32 pollSelectableOptionsCount = 20;
+    optional bytes messageSecret = 21;
+    optional int64 senderTimestampMs = 22;
+    optional string pollUpdateParentKey = 23;
+    optional PollEncValue encPollVote = 24;
+    message PollOption {
+        optional string name = 1;
+    }
+    
+}
+
+message MsgRowOpaqueData {
+    optional MsgOpaqueData currentMsg = 1;
+    optional MsgOpaqueData quotedMsg = 2;
+}
+
+message NoiseCertificate {
+    optional bytes details = 1;
+    optional bytes signature = 2;
+    message Details {
+        optional uint32 serial = 1;
+        optional string issuer = 2;
+        optional uint64 expires = 3;
+        optional string subject = 4;
+        optional bytes key = 5;
+    }
+    
+}
+
+message NotificationMessageInfo {
+    optional MessageKey key = 1;
+    optional Message message = 2;
+    optional uint64 messageTimestamp = 3;
+    optional string participant = 4;
+}
+
+message PastParticipant {
+    required string userJid = 1;
+    required LeaveReason leaveReason = 2;
+    required uint64 leaveTs = 3;
+    enum LeaveReason {
+        LEFT = 0;
+        REMOVED = 1;
+    }
+}
+
+message PastParticipants {
+    required string groupJid = 1;
+    repeated PastParticipant pastParticipants = 2;
+}
+
+message PaymentBackground {
+    optional string id = 1;
+    optional uint64 fileLength = 2;
+    optional uint32 width = 3;
+    optional uint32 height = 4;
+    optional string mimetype = 5;
+    optional fixed32 placeholderArgb = 6;
+    optional fixed32 textArgb = 7;
+    optional fixed32 subtextArgb = 8;
+    optional MediaData mediaData = 9;
+    optional Type type = 10;
+    message MediaData {
+        optional bytes mediaKey = 1;
+        optional int64 mediaKeyTimestamp = 2;
+        optional bytes fileSha256 = 3;
+        optional bytes fileEncSha256 = 4;
+        optional string directPath = 5;
+    }
+    
+    enum Type {
+        UNKNOWN = 0;
+        DEFAULT = 1;
+    }
+}
+
+message PaymentInfo {
+    optional Currency currencyDeprecated = 1;
+    optional uint64 amount1000 = 2;
+    optional string receiverJid = 3;
+    optional Status status = 4;
+    optional uint64 transactionTimestamp = 5;
+    optional MessageKey requestMessageKey = 6;
+    optional uint64 expiryTimestamp = 7;
+    optional bool futureproofed = 8;
+    optional string currency = 9;
+    optional TxnStatus txnStatus = 10;
+    optional bool useNoviFiatFormat = 11;
+    optional Money primaryAmount = 12;
+    optional Money exchangeAmount = 13;
+    enum Currency {
+        UNKNOWN_CURRENCY = 0;
+        INR = 1;
+    }
+    enum Status {
+        UNKNOWN_STATUS = 0;
+        PROCESSING = 1;
+        SENT = 2;
+        NEED_TO_ACCEPT = 3;
+        COMPLETE = 4;
+        COULD_NOT_COMPLETE = 5;
+        REFUNDED = 6;
+        EXPIRED = 7;
+        REJECTED = 8;
+        CANCELLED = 9;
+        WAITING_FOR_PAYER = 10;
+        WAITING = 11;
+    }
+    enum TxnStatus {
+        UNKNOWN = 0;
+        PENDING_SETUP = 1;
+        PENDING_RECEIVER_SETUP = 2;
+        INIT = 3;
+        SUCCESS = 4;
+        COMPLETED = 5;
+        FAILED = 6;
+        FAILED_RISK = 7;
+        FAILED_PROCESSING = 8;
+        FAILED_RECEIVER_PROCESSING = 9;
+        FAILED_DA = 10;
+        FAILED_DA_FINAL = 11;
+        REFUNDED_TXN = 12;
+        REFUND_FAILED = 13;
+        REFUND_FAILED_PROCESSING = 14;
+        REFUND_FAILED_DA = 15;
+        EXPIRED_TXN = 16;
+        AUTH_CANCELED = 17;
+        AUTH_CANCEL_FAILED_PROCESSING = 18;
+        AUTH_CANCEL_FAILED = 19;
+        COLLECT_INIT = 20;
+        COLLECT_SUCCESS = 21;
+        COLLECT_FAILED = 22;
+        COLLECT_FAILED_RISK = 23;
+        COLLECT_REJECTED = 24;
+        COLLECT_EXPIRED = 25;
+        COLLECT_CANCELED = 26;
+        COLLECT_CANCELLING = 27;
+        IN_REVIEW = 28;
+        REVERSAL_SUCCESS = 29;
+        REVERSAL_PENDING = 30;
+        REFUND_PENDING = 31;
+    }
+}
+
+message PendingKeyExchange {
+    optional uint32 sequence = 1;
+    optional bytes localBaseKey = 2;
+    optional bytes localBaseKeyPrivate = 3;
+    optional bytes localRatchetKey = 4;
+    optional bytes localRatchetKeyPrivate = 5;
+    optional bytes localIdentityKey = 7;
+    optional bytes localIdentityKeyPrivate = 8;
+}
+
+message PendingPreKey {
+    optional uint32 preKeyId = 1;
+    optional int32 signedPreKeyId = 3;
+    optional bytes baseKey = 2;
+}
+
+message PhotoChange {
+    optional bytes oldPhoto = 1;
+    optional bytes newPhoto = 2;
+    optional uint32 newPhotoId = 3;
+}
+
+message Point {
+    optional int32 xDeprecated = 1;
+    optional int32 yDeprecated = 2;
+    optional double x = 3;
+    optional double y = 4;
+}
+
+message PollAdditionalMetadata {
+    optional bool pollInvalidated = 1;
+}
+
+message PollEncValue {
+    optional bytes encPayload = 1;
+    optional bytes encIv = 2;
+}
+
+message PollUpdate {
+    optional MessageKey pollUpdateMessageKey = 1;
+    optional Message.PollVoteMessage vote = 2;
+    optional int64 senderTimestampMs = 3;
+}
+
+message PreKeyRecordStructure {
+    optional uint32 id = 1;
+    optional bytes publicKey = 2;
+    optional bytes privateKey = 3;
+}
+
+message Pushname {
+    optional string id = 1;
+    optional string pushname = 2;
+}
+
+message Reaction {
+    optional MessageKey key = 1;
+    optional string text = 2;
+    optional string groupingKey = 3;
+    optional int64 senderTimestampMs = 4;
+    optional bool unread = 5;
+}
+
+message RecentEmojiWeight {
+    optional string emoji = 1;
+    optional float weight = 2;
+}
+
+message RecordStructure {
+    optional SessionStructure currentSession = 1;
+    repeated SessionStructure previousSessions = 2;
+}
+
+message SenderChainKey {
+    optional uint32 iteration = 1;
+    optional bytes seed = 2;
+}
+
+message SenderKeyRecordStructure {
+    repeated SenderKeyStateStructure senderKeyStates = 1;
+}
+
+message SenderKeyStateStructure {
+    optional uint32 senderKeyId = 1;
+    optional SenderChainKey senderChainKey = 2;
+    optional SenderSigningKey senderSigningKey = 3;
+    repeated SenderMessageKey senderMessageKeys = 4;
+}
+
+message SenderMessageKey {
+    optional uint32 iteration = 1;
+    optional bytes seed = 2;
+}
+
+message SenderSigningKey {
+    optional bytes public = 1;
+    optional bytes private = 2;
+}
+
+message ServerErrorReceipt {
+    optional string stanzaId = 1;
+}
+
+message SessionStructure {
+    optional uint32 sessionVersion = 1;
+    optional bytes localIdentityPublic = 2;
+    optional bytes remoteIdentityPublic = 3;
+    optional bytes rootKey = 4;
+    optional uint32 previousCounter = 5;
+    optional Chain senderChain = 6;
+    repeated Chain receiverChains = 7;
+    optional PendingKeyExchange pendingKeyExchange = 8;
+    optional PendingPreKey pendingPreKey = 9;
+    optional uint32 remoteRegistrationId = 10;
+    optional uint32 localRegistrationId = 11;
+    optional bool needsRefresh = 12;
+    optional bytes aliceBaseKey = 13;
+}
+
+message SignedPreKeyRecordStructure {
+    optional uint32 id = 1;
+    optional bytes publicKey = 2;
+    optional bytes privateKey = 3;
+    optional bytes signature = 4;
+    optional fixed64 timestamp = 5;
+}
+
+message StatusPSA {
+    required uint64 campaignId = 44;
+    optional uint64 campaignExpirationTimestamp = 45;
+}
+
+message StickerMetadata {
+    optional string url = 1;
+    optional bytes fileSha256 = 2;
+    optional bytes fileEncSha256 = 3;
+    optional bytes mediaKey = 4;
+    optional string mimetype = 5;
+    optional uint32 height = 6;
+    optional uint32 width = 7;
+    optional string directPath = 8;
+    optional uint64 fileLength = 9;
+    optional float weight = 10;
+}
+
+message SyncActionData {
+    optional bytes index = 1;
+    optional SyncActionValue value = 2;
+    optional bytes padding = 3;
+    optional int32 version = 4;
+}
+
+message SyncActionValue {
+    optional int64 timestamp = 1;
+    optional StarAction starAction = 2;
+    optional ContactAction contactAction = 3;
+    optional MuteAction muteAction = 4;
+    optional PinAction pinAction = 5;
+    optional SecurityNotificationSetting securityNotificationSetting = 6;
+    optional PushNameSetting pushNameSetting = 7;
+    optional QuickReplyAction quickReplyAction = 8;
+    optional RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
+    optional LabelEditAction labelEditAction = 14;
+    optional LabelAssociationAction labelAssociationAction = 15;
+    optional LocaleSetting localeSetting = 16;
+    optional ArchiveChatAction archiveChatAction = 17;
+    optional DeleteMessageForMeAction deleteMessageForMeAction = 18;
+    optional KeyExpiration keyExpiration = 19;
+    optional MarkChatAsReadAction markChatAsReadAction = 20;
+    optional ClearChatAction clearChatAction = 21;
+    optional DeleteChatAction deleteChatAction = 22;
+    optional UnarchiveChatsSetting unarchiveChatsSetting = 23;
+    optional PrimaryFeature primaryFeature = 24;
+    optional AndroidUnsupportedActions androidUnsupportedActions = 26;
+    optional AgentAction agentAction = 27;
+    optional SubscriptionAction subscriptionAction = 28;
+    optional UserStatusMuteAction userStatusMuteAction = 29;
+    optional TimeFormatAction timeFormatAction = 30;
+    optional NuxAction nuxAction = 31;
+    optional PrimaryVersionAction primaryVersionAction = 32;
+    optional StickerAction stickerAction = 33;
+    message AgentAction {
+        optional string name = 1;
+        optional int32 deviceID = 2;
+        optional bool isDeleted = 3;
+    }
+    
+    message AndroidUnsupportedActions {
+        optional bool allowed = 1;
+    }
+    
+    message ArchiveChatAction {
+        optional bool archived = 1;
+        optional SyncActionValue.SyncActionMessageRange messageRange = 2;
+    }
+    
+    message ClearChatAction {
+        optional SyncActionValue.SyncActionMessageRange messageRange = 1;
+    }
+    
+    message ContactAction {
+        optional string fullName = 1;
+        optional string firstName = 2;
+    }
+    
+    message DeleteChatAction {
+        optional SyncActionValue.SyncActionMessageRange messageRange = 1;
+    }
+    
+    message DeleteMessageForMeAction {
+        optional bool deleteMedia = 1;
+        optional int64 messageTimestamp = 2;
+    }
+    
+    message KeyExpiration {
+        optional int32 expiredKeyEpoch = 1;
+    }
+    
+    message LabelAssociationAction {
+        optional bool labeled = 1;
+    }
+    
+    message LabelEditAction {
+        optional string name = 1;
+        optional int32 color = 2;
+        optional int32 predefinedId = 3;
+        optional bool deleted = 4;
+    }
+    
+    message LocaleSetting {
+        optional string locale = 1;
+    }
+    
+    message MarkChatAsReadAction {
+        optional bool read = 1;
+        optional SyncActionValue.SyncActionMessageRange messageRange = 2;
+    }
+    
+    message MuteAction {
+        optional bool muted = 1;
+        optional int64 muteEndTimestamp = 2;
+    }
+    
+    message NuxAction {
+        optional bool acknowledged = 1;
+    }
+    
+    message PinAction {
+        optional bool pinned = 1;
+    }
+    
+    message PrimaryFeature {
+        repeated string flags = 1;
+    }
+    
+    message PrimaryVersionAction {
+        optional string version = 1;
+    }
+    
+    message PushNameSetting {
+        optional string name = 1;
+    }
+    
+    message QuickReplyAction {
+        optional string shortcut = 1;
+        optional string message = 2;
+        repeated string keywords = 3;
+        optional int32 count = 4;
+        optional bool deleted = 5;
+    }
+    
+    message RecentEmojiWeightsAction {
+        repeated RecentEmojiWeight weights = 1;
+    }
+    
+    message SecurityNotificationSetting {
+        optional bool showNotification = 1;
+    }
+    
+    message StarAction {
+        optional bool starred = 1;
+    }
+    
+    message StickerAction {
+        optional string url = 1;
+        optional bytes fileEncSha256 = 2;
+        optional bytes mediaKey = 3;
+        optional string mimetype = 4;
+        optional uint32 height = 5;
+        optional uint32 width = 6;
+        optional string directPath = 7;
+        optional uint64 fileLength = 8;
+        optional bool isFavorite = 9;
+        optional uint32 deviceIdHint = 10;
+    }
+    
+    message SubscriptionAction {
+        optional bool isDeactivated = 1;
+        optional bool isAutoRenewing = 2;
+        optional int64 expirationDate = 3;
+    }
+    
+    message SyncActionMessageRange {
+        optional int64 lastMessageTimestamp = 1;
+        optional int64 lastSystemMessageTimestamp = 2;
+        repeated SyncActionValue.SyncActionMessage messages = 3;
+    }
+    
+    message SyncActionMessage {
+        optional MessageKey key = 1;
+        optional int64 timestamp = 2;
+    }
+    
+    message TimeFormatAction {
+        optional bool isTwentyFourHourFormatEnabled = 1;
+    }
+    
+    message UnarchiveChatsSetting {
+        optional bool unarchiveChats = 1;
+    }
+    
+    message UserStatusMuteAction {
+        optional bool muted = 1;
+    }
+    
+}
+
+message SyncdIndex {
+    optional bytes blob = 1;
+}
+
+message SyncdMutation {
+    optional SyncdOperation operation = 1;
+    optional SyncdRecord record = 2;
+    enum SyncdOperation {
+        SET = 0;
+        REMOVE = 1;
+    }
+}
+
+message SyncdMutations {
+    repeated SyncdMutation mutations = 1;
+}
+
+message SyncdPatch {
+    optional SyncdVersion version = 1;
+    repeated SyncdMutation mutations = 2;
+    optional ExternalBlobReference externalMutations = 3;
+    optional bytes snapshotMac = 4;
+    optional bytes patchMac = 5;
+    optional KeyId keyId = 6;
+    optional ExitCode exitCode = 7;
+    optional uint32 deviceIndex = 8;
+}
+
+message SyncdRecord {
+    optional SyncdIndex index = 1;
+    optional SyncdValue value = 2;
+    optional KeyId keyId = 3;
+}
+
+message SyncdSnapshot {
+    optional SyncdVersion version = 1;
+    repeated SyncdRecord records = 2;
+    optional bytes mac = 3;
+    optional KeyId keyId = 4;
+}
+
+message SyncdValue {
+    optional bytes blob = 1;
+}
+
+message SyncdVersion {
+    optional uint64 version = 1;
+}
+
+message TemplateButton {
+    optional uint32 index = 4;
+    oneof button {
+        TemplateButton.QuickReplyButton quickReplyButton = 1;
+        TemplateButton.URLButton urlButton = 2;
+        TemplateButton.CallButton callButton = 3;
+    }
+    message CallButton {
+        optional Message.HighlyStructuredMessage displayText = 1;
+        optional Message.HighlyStructuredMessage phoneNumber = 2;
+    }
+    
+    message QuickReplyButton {
+        optional Message.HighlyStructuredMessage displayText = 1;
+        optional string id = 2;
+    }
+    
+    message URLButton {
+        optional Message.HighlyStructuredMessage displayText = 1;
+        optional Message.HighlyStructuredMessage url = 2;
+    }
+    
+}
+
+message UserReceipt {
+    required string userJid = 1;
+    optional int64 receiptTimestamp = 2;
+    optional int64 readTimestamp = 3;
+    optional int64 playedTimestamp = 4;
+    repeated string pendingDeviceJid = 5;
+    repeated string deliveredDeviceJid = 6;
+}
+
+message VerifiedNameCertificate {
+    optional bytes details = 1;
+    optional bytes signature = 2;
+    optional bytes serverSignature = 3;
+    message Details {
+        optional uint64 serial = 1;
+        optional string issuer = 2;
+        optional string verifiedName = 4;
+        repeated LocalizedName localizedNames = 8;
+        optional uint64 issueTime = 10;
+    }
+    
+}
+
+message WallpaperSettings {
+    optional string filename = 1;
+    optional uint32 opacity = 2;
+}
+
+message WebFeatures {
+    optional Flag labelsDisplay = 1;
+    optional Flag voipIndividualOutgoing = 2;
+    optional Flag groupsV3 = 3;
+    optional Flag groupsV3Create = 4;
+    optional Flag changeNumberV2 = 5;
+    optional Flag queryStatusV3Thumbnail = 6;
+    optional Flag liveLocations = 7;
+    optional Flag queryVname = 8;
+    optional Flag voipIndividualIncoming = 9;
+    optional Flag quickRepliesQuery = 10;
+    optional Flag payments = 11;
+    optional Flag stickerPackQuery = 12;
+    optional Flag liveLocationsFinal = 13;
+    optional Flag labelsEdit = 14;
+    optional Flag mediaUpload = 15;
+    optional Flag mediaUploadRichQuickReplies = 18;
+    optional Flag vnameV2 = 19;
+    optional Flag videoPlaybackUrl = 20;
+    optional Flag statusRanking = 21;
+    optional Flag voipIndividualVideo = 22;
+    optional Flag thirdPartyStickers = 23;
+    optional Flag frequentlyForwardedSetting = 24;
+    optional Flag groupsV4JoinPermission = 25;
+    optional Flag recentStickers = 26;
+    optional Flag catalog = 27;
+    optional Flag starredStickers = 28;
+    optional Flag voipGroupCall = 29;
+    optional Flag templateMessage = 30;
+    optional Flag templateMessageInteractivity = 31;
+    optional Flag ephemeralMessages = 32;
+    optional Flag e2ENotificationSync = 33;
+    optional Flag recentStickersV2 = 34;
+    optional Flag recentStickersV3 = 36;
+    optional Flag userNotice = 37;
+    optional Flag support = 39;
+    optional Flag groupUiiCleanup = 40;
+    optional Flag groupDogfoodingInternalOnly = 41;
+    optional Flag settingsSync = 42;
+    optional Flag archiveV2 = 43;
+    optional Flag ephemeralAllowGroupMembers = 44;
+    optional Flag ephemeral24HDuration = 45;
+    optional Flag mdForceUpgrade = 46;
+    optional Flag disappearingMode = 47;
+    optional Flag externalMdOptInAvailable = 48;
+    optional Flag noDeleteMessageTimeLimit = 49;
+    enum Flag {
+        NOT_STARTED = 0;
+        FORCE_UPGRADE = 1;
+        DEVELOPMENT = 2;
+        PRODUCTION = 3;
+    }
+}
+
+message WebMessageInfo {
+    required MessageKey key = 1;
+    optional Message message = 2;
+    optional uint64 messageTimestamp = 3;
+    optional Status status = 4;
+    optional string participant = 5;
+    optional uint64 messageC2STimestamp = 6;
+    optional bool ignore = 16;
+    optional bool starred = 17;
+    optional bool broadcast = 18;
+    optional string pushName = 19;
+    optional bytes mediaCiphertextSha256 = 20;
+    optional bool multicast = 21;
+    optional bool urlText = 22;
+    optional bool urlNumber = 23;
+    optional StubType messageStubType = 24;
+    optional bool clearMedia = 25;
+    repeated string messageStubParameters = 26;
+    optional uint32 duration = 27;
+    repeated string labels = 28;
+    optional PaymentInfo paymentInfo = 29;
+    optional Message.LiveLocationMessage finalLiveLocation = 30;
+    optional PaymentInfo quotedPaymentInfo = 31;
+    optional uint64 ephemeralStartTimestamp = 32;
+    optional uint32 ephemeralDuration = 33;
+    optional bool ephemeralOffToOn = 34;
+    optional bool ephemeralOutOfSync = 35;
+    optional BizPrivacyStatus bizPrivacyStatus = 36;
+    optional string verifiedBizName = 37;
+    optional MediaData mediaData = 38;
+    optional PhotoChange photoChange = 39;
+    repeated UserReceipt userReceipt = 40;
+    repeated Reaction reactions = 41;
+    optional MediaData quotedStickerData = 42;
+    optional bytes futureproofData = 43;
+    optional StatusPSA statusPsa = 44;
+    repeated PollUpdate pollUpdates = 45;
+    optional PollAdditionalMetadata pollAdditionalMetadata = 46;
+    optional string agentId = 47;
+    optional bool statusAlreadyViewed = 48;
+    optional bytes messageSecret = 49;
+    optional KeepInChat keepInChat = 50;
+    optional string originalSelfAuthorUserJidString = 51;
+    optional uint64 revokeMessageTimestamp = 52;
+    enum BizPrivacyStatus {
+        E2EE = 0;
+        FB = 2;
+        BSP = 1;
+        BSP_AND_FB = 3;
+    }
+    enum Status {
+        ERROR = 0;
+        PENDING = 1;
+        SERVER_ACK = 2;
+        DELIVERY_ACK = 3;
+        READ = 4;
+        PLAYED = 5;
+    }
+    enum StubType {
+        UNKNOWN = 0;
+        REVOKE = 1;
+        CIPHERTEXT = 2;
+        FUTUREPROOF = 3;
+        NON_VERIFIED_TRANSITION = 4;
+        UNVERIFIED_TRANSITION = 5;
+        VERIFIED_TRANSITION = 6;
+        VERIFIED_LOW_UNKNOWN = 7;
+        VERIFIED_HIGH = 8;
+        VERIFIED_INITIAL_UNKNOWN = 9;
+        VERIFIED_INITIAL_LOW = 10;
+        VERIFIED_INITIAL_HIGH = 11;
+        VERIFIED_TRANSITION_ANY_TO_NONE = 12;
+        VERIFIED_TRANSITION_ANY_TO_HIGH = 13;
+        VERIFIED_TRANSITION_HIGH_TO_LOW = 14;
+        VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15;
+        VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16;
+        VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17;
+        VERIFIED_TRANSITION_NONE_TO_LOW = 18;
+        VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19;
+        GROUP_CREATE = 20;
+        GROUP_CHANGE_SUBJECT = 21;
+        GROUP_CHANGE_ICON = 22;
+        GROUP_CHANGE_INVITE_LINK = 23;
+        GROUP_CHANGE_DESCRIPTION = 24;
+        GROUP_CHANGE_RESTRICT = 25;
+        GROUP_CHANGE_ANNOUNCE = 26;
+        GROUP_PARTICIPANT_ADD = 27;
+        GROUP_PARTICIPANT_REMOVE = 28;
+        GROUP_PARTICIPANT_PROMOTE = 29;
+        GROUP_PARTICIPANT_DEMOTE = 30;
+        GROUP_PARTICIPANT_INVITE = 31;
+        GROUP_PARTICIPANT_LEAVE = 32;
+        GROUP_PARTICIPANT_CHANGE_NUMBER = 33;
+        BROADCAST_CREATE = 34;
+        BROADCAST_ADD = 35;
+        BROADCAST_REMOVE = 36;
+        GENERIC_NOTIFICATION = 37;
+        E2E_IDENTITY_CHANGED = 38;
+        E2E_ENCRYPTED = 39;
+        CALL_MISSED_VOICE = 40;
+        CALL_MISSED_VIDEO = 41;
+        INDIVIDUAL_CHANGE_NUMBER = 42;
+        GROUP_DELETE = 43;
+        GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44;
+        CALL_MISSED_GROUP_VOICE = 45;
+        CALL_MISSED_GROUP_VIDEO = 46;
+        PAYMENT_CIPHERTEXT = 47;
+        PAYMENT_FUTUREPROOF = 48;
+        PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49;
+        PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50;
+        PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51;
+        PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52;
+        PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53;
+        PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54;
+        PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55;
+        PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56;
+        PAYMENT_ACTION_REQUEST_DECLINED = 57;
+        PAYMENT_ACTION_REQUEST_EXPIRED = 58;
+        PAYMENT_ACTION_REQUEST_CANCELLED = 59;
+        BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60;
+        BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61;
+        BIZ_INTRO_TOP = 62;
+        BIZ_INTRO_BOTTOM = 63;
+        BIZ_NAME_CHANGE = 64;
+        BIZ_MOVE_TO_CONSUMER_APP = 65;
+        BIZ_TWO_TIER_MIGRATION_TOP = 66;
+        BIZ_TWO_TIER_MIGRATION_BOTTOM = 67;
+        OVERSIZED = 68;
+        GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69;
+        GROUP_V4_ADD_INVITE_SENT = 70;
+        GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71;
+        CHANGE_EPHEMERAL_SETTING = 72;
+        E2E_DEVICE_CHANGED = 73;
+        VIEWED_ONCE = 74;
+        E2E_ENCRYPTED_NOW = 75;
+        BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76;
+        BLUE_MSG_BSP_FB_TO_SELF_FB = 77;
+        BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78;
+        BLUE_MSG_BSP_FB_UNVERIFIED = 79;
+        BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80;
+        BLUE_MSG_BSP_FB_VERIFIED = 81;
+        BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82;
+        BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83;
+        BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84;
+        BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85;
+        BLUE_MSG_BSP_PREMISE_VERIFIED = 86;
+        BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87;
+        BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88;
+        BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89;
+        BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90;
+        BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91;
+        BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92;
+        BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93;
+        BLUE_MSG_SELF_FB_UNVERIFIED = 94;
+        BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95;
+        BLUE_MSG_SELF_FB_VERIFIED = 96;
+        BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97;
+        BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98;
+        BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99;
+        BLUE_MSG_SELF_PREMISE_VERIFIED = 100;
+        BLUE_MSG_TO_BSP_FB = 101;
+        BLUE_MSG_TO_CONSUMER = 102;
+        BLUE_MSG_TO_SELF_FB = 103;
+        BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104;
+        BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105;
+        BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106;
+        BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107;
+        BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108;
+        BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109;
+        BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110;
+        BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111;
+        BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112;
+        BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113;
+        BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114;
+        BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115;
+        BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116;
+        BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117;
+        E2E_IDENTITY_UNAVAILABLE = 118;
+        GROUP_CREATING = 119;
+        GROUP_CREATE_FAILED = 120;
+        GROUP_BOUNCED = 121;
+        BLOCK_CONTACT = 122;
+        EPHEMERAL_SETTING_NOT_APPLIED = 123;
+        SYNC_FAILED = 124;
+        SYNCING = 125;
+        BIZ_PRIVACY_MODE_INIT_FB = 126;
+        BIZ_PRIVACY_MODE_INIT_BSP = 127;
+        BIZ_PRIVACY_MODE_TO_FB = 128;
+        BIZ_PRIVACY_MODE_TO_BSP = 129;
+        DISAPPEARING_MODE = 130;
+        E2E_DEVICE_FETCH_FAILED = 131;
+        ADMIN_REVOKE = 132;
+        GROUP_INVITE_LINK_GROWTH_LOCKED = 133;
+        COMMUNITY_LINK_PARENT_GROUP = 134;
+        COMMUNITY_LINK_SIBLING_GROUP = 135;
+        COMMUNITY_LINK_SUB_GROUP = 136;
+        COMMUNITY_UNLINK_PARENT_GROUP = 137;
+        COMMUNITY_UNLINK_SIBLING_GROUP = 138;
+        COMMUNITY_UNLINK_SUB_GROUP = 139;
+        GROUP_PARTICIPANT_ACCEPT = 140;
+        GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141;
+        COMMUNITY_CREATE = 142;
+        EPHEMERAL_KEEP_IN_CHAT = 143;
+        GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144;
+        GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145;
+        INTEGRITY_UNLINK_PARENT_GROUP = 146;
+        COMMUNITY_PARTICIPANT_PROMOTE = 147;
+        COMMUNITY_PARTICIPANT_DEMOTE = 148;
+        COMMUNITY_PARENT_GROUP_DELETED = 149;
+    }
+}
+
+message WebNotificationsInfo {
+    optional uint64 timestamp = 2;
+    optional uint32 unreadChats = 3;
+    optional uint32 notifyMessageCount = 4;
+    repeated WebMessageInfo notifyMessages = 5;
+}
diff --git a/protocols/WhatsApp/src/proto.cpp b/protocols/WhatsApp/src/proto.cpp
new file mode 100644
index 0000000000..0b6fab3b19
--- /dev/null
+++ b/protocols/WhatsApp/src/proto.cpp
@@ -0,0 +1,333 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+struct SearchParam
+{
+	SearchParam(const wchar_t *_jid, LONG _id) :
+		jid(_jid), id(_id) 
+		{}
+
+	std::wstring jid;
+	LONG id;
+};
+
+static int CompareOwnMsgs(const WAOwnMessage *p1, const WAOwnMessage *p2)
+{
+	return strcmp(p1->szPrefix, p2->szPrefix);
+}
+
+static int CompareUsers(const WAUser *p1, const WAUser *p2)
+{
+	return strcmp(p1->szId, p2->szId);
+}
+
+static int CompareCollections(const WACollection *p1, const WACollection *p2)
+{
+	return strcmp(p1->szName, p2->szName);
+}
+
+WhatsAppProto::WhatsAppProto(const char *proto_name, const wchar_t *username) :
+	PROTO<WhatsAppProto>(proto_name, username),
+	m_impl(*this),
+	m_signalStore(this, ""),
+	m_szJid(getMStringA(DBKEY_JID)),
+	m_tszDefaultGroup(getWStringA(DBKEY_DEF_GROUP)),
+	m_arUsers(10, CompareUsers),
+	m_arDevices(1),
+	m_arOwnMsgs(1, CompareOwnMsgs),
+	m_arPersistent(1),
+	m_arPacketQueue(10),
+	m_arCollections(10, CompareCollections),
+
+	m_wszNick(this, "Nick"),
+	m_wszDefaultGroup(this, "DefaultGroup", L"WhatsApp"),
+	m_bUsePopups(this, "UsePopups", true),
+	m_bHideGroupchats(this, "HideChats", true)
+{
+	db_set_resident(m_szModuleName, "StatusMsg");
+
+	CreateProtoService(PS_CREATEACCMGRUI, &WhatsAppProto::SvcCreateAccMgrUI);
+
+	CreateProtoService(PS_GETAVATARINFO, &WhatsAppProto::GetAvatarInfo);
+	CreateProtoService(PS_GETAVATARCAPS, &WhatsAppProto::GetAvatarCaps);
+	CreateProtoService(PS_GETMYAVATAR, &WhatsAppProto::GetMyAvatar);
+	CreateProtoService(PS_SETMYAVATAR, &WhatsAppProto::SetMyAvatar);
+
+	HookProtoEvent(ME_OPT_INITIALISE, &WhatsAppProto::OnOptionsInit);
+
+	InitCollections();
+	InitPopups();
+	InitPersistentHandlers();
+
+	// Create standard network connection
+	wchar_t descr[512];
+	mir_snwprintf(descr, TranslateT("%s (server)"), m_tszUserName);
+
+	NETLIBUSER nlu = {};
+	nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE;
+	nlu.szSettingsModule = m_szModuleName;
+	nlu.szDescriptiveName.w = descr;
+	m_hNetlibUser = Netlib_RegisterUser(&nlu);
+
+	// Temporary folder
+	CreateDirectoryTreeW(CMStringW(VARSW(L"%miranda_userdata%")) + L"\\" + _A2T(m_szModuleName));
+
+	// Avatars folder
+	m_tszAvatarFolder = CMStringW(VARSW(L"%miranda_avatarcache%")) + L"\\" + m_tszUserName;
+	DWORD dwAttributes = GetFileAttributes(m_tszAvatarFolder.c_str());
+	if (dwAttributes == 0xffffffff || (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
+		CreateDirectoryTreeW(m_tszAvatarFolder.c_str());
+
+	// default contacts group
+	if (m_tszDefaultGroup == NULL)
+		m_tszDefaultGroup = mir_wstrdup(L"WhatsApp");
+	Clist_GroupCreate(0, m_tszDefaultGroup);
+
+	// groupchat initialization
+	GCREGISTER gcr = {};
+	gcr.dwFlags = GC_TYPNOTIF;
+	gcr.ptszDispName = m_tszUserName;
+	gcr.pszModule = m_szModuleName;
+	Chat_Register(&gcr);
+}
+
+WhatsAppProto::~WhatsAppProto()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// OnModulesLoaded emulator for an account
+
+void WhatsAppProto::OnModulesLoaded()
+{
+	// initialize contacts cache
+	m_arUsers.insert(new WAUser(0, m_szJid, false));
+
+	for (auto &cc : AccContacts()) {
+		bool bIsChat = isChatRoom(cc);
+		CMStringA szId(getMStringA(cc, bIsChat ? "ChatRoomID" : DBKEY_JID));
+		if (!szId.IsEmpty())
+			m_arUsers.insert(new WAUser(cc, szId, bIsChat));
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// PROTO_INTERFACE implementation
+
+MCONTACT WhatsAppProto::AddToList(int flags, PROTOSEARCHRESULT *psr)
+{
+	if (psr->id.w == nullptr)
+		return NULL;
+
+	auto *pUser = AddUser(T2Utf(psr->id.w), (flags & PALF_TEMPORARY) != 0);
+	db_unset(pUser->hContact, "CList", "NotOnList");
+	
+	return pUser->hContact;
+}
+
+INT_PTR WhatsAppProto::GetCaps(int type, MCONTACT)
+{
+	switch (type) {
+	case PFLAGNUM_1:
+		return PF1_IM | PF1_FILE | PF1_CHAT | PF1_BASICSEARCH | PF1_ADDSEARCHRES | PF1_MODEMSGRECV;
+	case PFLAGNUM_2:
+		return PF2_ONLINE;
+	case PFLAGNUM_3:
+		return 0;
+	case PFLAGNUM_4:
+		return PF4_NOCUSTOMAUTH | PF4_NOAUTHDENYREASON | PF4_IMSENDOFFLINE | PF4_OFFLINEFILES | PF4_SUPPORTTYPING | PF4_AVATARS | PF4_SERVERMSGID;
+	case PFLAGNUM_5:
+		return 0;
+	case PFLAG_UNIQUEIDTEXT:
+		return (DWORD_PTR)"WhatsApp ID";
+	}
+	return 0;
+}
+
+int WhatsAppProto::SetStatus(int new_status)
+{
+	if (m_iDesiredStatus == new_status)
+		return 0;
+
+	if (!mir_wstrlen(m_wszNick)) {
+		Popup(0, LPGENW("You need to specify nick name in the Options dialog"), LPGENW("Error"));
+		return 0;
+	}
+
+	int oldStatus = m_iStatus;
+
+	// Routing statuses not supported by WhatsApp
+	switch (new_status) {
+	case ID_STATUS_OFFLINE:
+		m_iDesiredStatus = new_status;
+		break;
+
+	case ID_STATUS_ONLINE:
+	case ID_STATUS_FREECHAT:
+	default:
+		m_iDesiredStatus = ID_STATUS_ONLINE;
+		break;
+	}
+
+	if (m_iDesiredStatus == ID_STATUS_OFFLINE) {
+		SetServerStatus(m_iDesiredStatus);
+
+		if (m_hServerConn != nullptr)
+			Netlib_Shutdown(m_hServerConn);
+
+		m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE;
+		ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
+	}
+	else if (m_hServerConn == nullptr && !IsStatusConnecting(m_iStatus)) {
+		m_iStatus = ID_STATUS_CONNECTING;
+		ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
+
+		ForkThread(&WhatsAppProto::ServerThread);
+	}
+	else if (m_hServerConn != nullptr) {
+		SetServerStatus(m_iDesiredStatus);
+
+		m_iStatus = m_iDesiredStatus;
+		ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
+	}
+	else ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnSendMessage(const JSONNode &node, void*)
+{
+	CMStringA szPrefix= node["$id$"].as_mstring();
+
+	WAOwnMessage tmp(0, 0, szPrefix);
+	{
+		mir_cslock lck(m_csOwnMessages);
+		auto *pOwn = m_arOwnMsgs.find(&tmp);
+		if (pOwn == nullptr)
+			return;
+		
+		tmp.pktId = pOwn->pktId;
+		tmp.hContact = pOwn->hContact;
+		m_arOwnMsgs.remove(pOwn);
+	}
+
+	int status = node["status"].as_int();
+	if (status == 200)
+		ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_SUCCESS, (HANDLE)tmp.pktId);
+	else {
+		CMStringW wszError(FORMAT, TranslateT("Operation failed with server error status %d"), status);
+		ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_FAILED, (HANDLE)tmp.pktId, LPARAM(wszError.c_str()));
+	}
+}
+
+int WhatsAppProto::SendMsg(MCONTACT hContact, int, const char *pszMsg)
+{
+	ptrA jid(getStringA(hContact, DBKEY_JID));
+	if (jid == nullptr || pszMsg == nullptr)
+		return 0;
+
+	if (!isOnline()) {
+		debugLogA("No connection");
+		return 0;
+	}
+
+	char msgId[16], szMsgId[33];
+	Utils_GetRandom(msgId, sizeof(msgId));
+	bin2hex(msgId, sizeof(msgId), szMsgId);
+
+	auto *key = new proto::MessageKey();
+	key->set_remotejid(jid);
+	key->set_fromme(true);
+	key->set_id(szMsgId);
+
+	proto::WebMessageInfo msg;
+	msg.set_allocated_key(key);
+	msg.mutable_message()->set_conversation(pszMsg);
+	msg.set_messagetimestamp(_time64(0));
+
+	size_t cbBinaryLen = msg.ByteSizeLong();
+	mir_ptr<BYTE> pBuf((BYTE *)mir_alloc(cbBinaryLen));
+	msg.SerializeToArray(pBuf, (int)cbBinaryLen);
+
+	WANode payLoad;
+	payLoad.title = "action";
+	payLoad.addAttr("type", "relay");
+	payLoad.content.assign(pBuf, cbBinaryLen);
+	
+	int pktId = WSSendNode(payLoad);
+
+	mir_cslock lck(m_csOwnMessages);
+	m_arOwnMsgs.insert(new WAOwnMessage(pktId, hContact, szMsgId));
+	return pktId;
+}
+
+int WhatsAppProto::UserIsTyping(MCONTACT hContact, int)
+{
+	if (hContact && isOnline()) {
+		ptrA jid(getStringA(hContact, DBKEY_JID));
+		if (jid && isOnline()) {
+		}
+	}
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// contacts search
+
+void WhatsAppProto::SearchAckThread(void *targ)
+{
+	Sleep(100);
+
+	SearchParam *param = (SearchParam*)targ;
+	PROTOSEARCHRESULT psr = {};
+	psr.cbSize = sizeof(psr);
+	psr.flags = PSR_UNICODE;
+	psr.nick.w = psr.firstName.w = psr.lastName.w = L"";
+	psr.id.w = (wchar_t*)param->jid.c_str();
+
+	ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_DATA, (HANDLE)param->id, (LPARAM)&psr);
+	ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_SUCCESS, (HANDLE)param->id, 0);
+
+	delete param;
+}
+
+HANDLE WhatsAppProto::SearchBasic(const wchar_t* id)
+{
+	if (!isOnline())
+		return nullptr;
+
+	// fake - we always accept search
+	SearchParam *param = new SearchParam(id, -1);
+	ForkThread(&WhatsAppProto::SearchAckThread, param);
+	return (HANDLE)param->id;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+static int enumCollections(const char *szSetting, void *param)
+{
+	auto *pList = (LIST<char> *)param;
+	if (!memcmp(szSetting, "Collection_", 11))
+		pList->insert(mir_strdup(szSetting));
+	return 0;
+}
+
+void WhatsAppProto::InitCollections()
+{
+	LIST<char> settings(10);
+	db_enum_settings(0, enumCollections, m_szModuleName, &settings);
+
+	for (auto &it : settings) {
+		m_arCollections.insert(new WACollection(it + 11, getDword(it)));
+		mir_free(it);
+	}
+}
diff --git a/protocols/WhatsApp/src/proto.h b/protocols/WhatsApp/src/proto.h
new file mode 100644
index 0000000000..d5fb32e80d
--- /dev/null
+++ b/protocols/WhatsApp/src/proto.h
@@ -0,0 +1,425 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#if !defined(PROTO_H)
+#define PROTO_H
+
+#define S_WHATSAPP_NET "@s.whatsapp.net"
+#define APP_VERSION "2.2230.15"
+#define KEY_BUNDLE_TYPE "\x05"
+
+class WhatsAppProto;
+typedef void (WhatsAppProto:: *WA_PKT_HANDLER)(const WANode &node);
+
+struct WAMSG
+{
+	union {
+		uint32_t dwFlags = 0;
+		struct {
+			bool bPrivateChat : 1;
+			bool bGroupChat : 1;
+			bool bDirectStatus : 1;
+			bool bOtherStatus : 1;
+			bool bPeerBroadcast : 1;
+			bool bOtherBroadcast : 1;
+			bool bOffline : 1;
+		};
+	};
+};
+
+struct WARequest
+{
+	WARequest(const CMStringA &_1, WA_PKT_HANDLER _2, void *_3 = nullptr) :
+		szPacketId(_1),
+		pHandler(_2),
+		pUserInfo(_3)
+	{}
+
+	CMStringA szPacketId;
+	WA_PKT_HANDLER pHandler;
+	void *pUserInfo;
+};
+
+struct WADevice
+{
+	WADevice(const char *_1, int _2) :
+		jid(_1),
+		key_index(_2)
+	{}
+
+	WAJid jid;
+	int key_index;
+};
+
+struct WAPersistentHandler
+{
+	WAPersistentHandler(const char *_1, const char *_2, const char *_3, const char *_4, WA_PKT_HANDLER _5) :
+		pszTitle(_1), pszType(_2), pszXmlns(_3), pszChild(_4), pHandler(_5)
+	{}
+
+	const char *pszTitle, *pszType, *pszXmlns, *pszChild;
+	WA_PKT_HANDLER pHandler;
+};
+
+struct WAHistoryMessage
+{
+	CMStringA jid, text;
+	DWORD timestamp;
+};
+
+struct WAUser
+{
+	WAUser(MCONTACT _1, const char *_2, bool _3 = false) :
+		hContact(_1),
+		szId(mir_strdup(_2)),
+		bIsGroupChat(_3),
+		arHistory(1)
+	{
+	}
+
+	~WAUser()
+	{
+		mir_free(szId);
+	}
+
+	MCONTACT hContact;
+	DWORD dwModifyTag = 0;
+	char *szId;
+	bool bInited = false, bIsGroupChat;
+	SESSION_INFO *si = 0;
+	DWORD m_time1 = 0, m_time2 = 0;
+	OBJLIST<WAHistoryMessage> arHistory;
+};
+
+struct WAOwnMessage
+{
+	WAOwnMessage(int _1, MCONTACT _2, const char *_3) :
+		pktId(_1),
+		hContact(_2),
+		szPrefix(_3)
+	{}
+
+	int pktId;
+	MCONTACT hContact;
+	CMStringA szPrefix;
+};
+
+struct WACollection
+{
+	WACollection(const char *_1, int _2) :
+		szName(mir_strdup(_1)),
+		version(_2)
+	{}
+
+	ptrA szName;
+	int  version;
+
+	MBinBuffer hash;
+	std::map<std::string, std::string> indexValueMap;
+
+	void parseRecord(const proto::SyncdRecord &rec, bool bSet);
+};
+
+class WANoise
+{
+	friend class WhatsAppProto;
+
+	WhatsAppProto *ppro;
+	int readCounter = 0, writeCounter = 0;
+	bool bInitFinished = false, bSendIntro = false;
+	MBinBuffer salt, encKey, decKey;
+	uint8_t hash[32];
+
+	struct {
+		MBinBuffer priv, pub;
+	} noiseKeys, ephemeral;
+
+	void deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read);
+	void mixIntoKey(const void *n, const void *p);
+	void updateHash(const void *pData, size_t cbLen);
+
+public:
+	WANoise(WhatsAppProto *_ppro);
+
+	void finish();
+	void init();
+
+	MBinBuffer decrypt(const void *pData, size_t cbLen);
+	MBinBuffer encrypt(const void *pData, size_t cbLen);
+
+	size_t     decodeFrame(const void *&pData, size_t &cbLen);
+	MBinBuffer encodeFrame(const void *pData, size_t cbLen);
+};
+
+class MSignalSession : public MZeroedObject
+{
+	friend class MSignalStore;
+	signal_protocol_address address;
+	session_cipher *cipher = nullptr;
+
+public:
+	CMStringA szName;
+	MBinBuffer sessionData, userData;
+
+	MSignalSession(const CMStringA &_1, int _2);
+	~MSignalSession();
+
+	bool hasAddress(const char *name, size_t name_len) const;
+
+	__forceinline session_cipher* getCipher(void) const { return cipher; }
+	__forceinline int getDeviceId() const { return address.device_id; }
+};
+
+class MSignalStore
+{
+	void init();
+
+	signal_context *m_pContext;
+	signal_protocol_store_context *m_pStore;
+
+public:
+	PROTO_INTERFACE *pProto;
+	const char *prefix;
+
+	OBJLIST<MSignalSession> arSessions;
+
+	struct
+	{
+		MBinBuffer priv, pub;
+	}
+	signedIdentity;
+
+	struct
+	{
+		MBinBuffer priv, pub, signature;
+		uint32_t keyid;
+	} preKey;
+
+	MSignalStore(PROTO_INTERFACE *_1, const char *_2);
+	~MSignalStore();
+
+	__forceinline signal_context *CTX() const { return m_pContext; }
+
+	MSignalSession *createSession(const CMStringA &szName, int deviceId);
+
+	signal_buffer* decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted);
+	signal_buffer* decryptGroupSignalProto(const CMStringA &from, const CMStringA &author, const MBinBuffer &encrypted);
+
+	void generatePrekeys(int count);
+
+	void processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &msg);
+};
+
+class WhatsAppProto : public PROTO<WhatsAppProto>
+{
+	friend class WANoise;
+
+	class CWhatsAppProtoImpl
+	{
+		friend class WhatsAppProto;
+		WhatsAppProto &m_proto;
+
+		CTimer m_keepAlive;
+		void OnKeepAlive(CTimer *) {
+			m_proto.SendKeepAlive();
+		}
+
+		CWhatsAppProtoImpl(WhatsAppProto &pro) :
+			m_proto(pro),
+			m_keepAlive(Miranda_GetSystemWindow(), UINT_PTR(this))
+		{
+			m_keepAlive.OnEvent = Callback(this, &CWhatsAppProtoImpl::OnKeepAlive);
+		}
+	} m_impl;
+
+
+	bool m_bTerminated, m_bRespawn;
+	ptrW m_tszDefaultGroup;
+
+	CMStringA m_szJid;
+	CMStringW m_tszAvatarFolder;
+
+	EVP_PKEY *m_pKeys; // private & public keys
+	WANoise *m_noise;
+
+	void UploadMorePrekeys();
+
+	// App state management
+	OBJLIST<WACollection> m_arCollections;
+
+	void InitCollections();
+	void ResyncServer(const OBJLIST<WACollection> &task);
+
+	__forceinline WACollection *FindCollection(const char *pszName)
+	{	return m_arCollections.find((WACollection *)&pszName);
+	}
+
+	// Contacts management /////////////////////////////////////////////////////////////////
+
+	mir_cs m_csUsers;
+	OBJLIST<WAUser> m_arUsers;
+
+	mir_cs m_csOwnMessages;
+	OBJLIST<WAOwnMessage> m_arOwnMsgs;
+
+	OBJLIST<WADevice> m_arDevices;
+
+	WAUser* FindUser(const char *szId);
+	WAUser* AddUser(const char *szId, bool bTemporary, bool isChat = false);
+
+	// Group chats /////////////////////////////////////////////////////////////////////////
+
+	void InitChat(WAUser *pUser);
+
+	// UI //////////////////////////////////////////////////////////////////////////////////
+
+	void CloseQrDialog();
+	bool ShowQrCode(const CMStringA &ref);
+
+	/// Network ////////////////////////////////////////////////////////////////////////////
+
+	time_t m_lastRecvTime;
+	HNETLIBCONN m_hServerConn;
+
+	mir_cs m_csPacketQueue;
+	OBJLIST<WARequest> m_arPacketQueue;
+
+	LIST<WAPersistentHandler> m_arPersistent;
+	WA_PKT_HANDLER FindPersistentHandler(const WANode &node);
+
+	int m_iPacketId;
+	uint16_t m_wMsgPrefix[2];
+	CMStringA GenerateMessageId();
+	void ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg);
+
+	bool WSReadPacket(const WSHeader &hdr, MBinBuffer &buf);
+	int  WSSend(const MessageLite &msg);
+	int  WSSendNode(WANode &node, WA_PKT_HANDLER = nullptr);
+
+	MBinBuffer DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszType);
+	CMStringW  GetTmpFileName(const char *pszClass, const char *addition);
+
+	void OnLoggedIn(void);
+	void OnLoggedOut(void);
+	void ServerThreadWorker(void);
+	void ShutdownSession(void);
+
+	void SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType);
+	void SendKeepAlive();
+	void SetServerStatus(int iStatus);
+
+	/// Popups /////////////////////////////////////////////////////////////////////////////
+
+	HANDLE m_hPopupClass;
+	CMOption<bool> m_bUsePopups;
+
+	void InitPopups(void);
+	void Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle);
+
+	/// Request handlers ///////////////////////////////////////////////////////////////////
+
+	void OnGetAvatarInfo(const JSONNode &node, void*);
+	void OnGetChatInfo(const JSONNode &node, void*);
+	void OnSendMessage(const JSONNode &node, void*);
+
+	void OnProcessHandshake(const void *pData, int cbLen);
+	
+	void InitPersistentHandlers();
+	void OnAccountSync(const WANode &node);
+	void OnIqBlockList(const WANode &node);
+	void OnIqCountPrekeys(const WANode &node);
+	void OnIqDoNothing(const WANode &node);
+	void OnIqPairDevice(const WANode &node);
+	void OnIqPairSuccess(const WANode &node);
+	void OnIqResult(const WANode &node);
+	void OnIqServerSync(const WANode &node);
+	void OnNotifyEncrypt(const WANode &node);
+	void OnReceiveInfo(const WANode &node);
+	void OnReceiveMessage(const WANode &node);
+	void OnServerSync(const WANode &node);
+	void OnStreamError(const WANode &node);
+	void OnSuccess(const WANode &node);
+
+	// Signal
+	MSignalStore m_signalStore;
+
+	// Binary packets
+	void ProcessBinaryPacket(const void *pData, size_t cbLen);
+
+	// unzip operations
+	MBinBuffer unzip(const MBinBuffer &src);
+
+	/// Avatars ////////////////////////////////////////////////////////////////////////////
+	CMStringW GetAvatarFileName(MCONTACT hContact);
+
+	INT_PTR __cdecl GetAvatarInfo(WPARAM, LPARAM);
+	INT_PTR __cdecl GetAvatarCaps(WPARAM, LPARAM);
+	INT_PTR __cdecl GetMyAvatar(WPARAM, LPARAM);
+	INT_PTR __cdecl SetMyAvatar(WPARAM, LPARAM);
+
+public:
+	WhatsAppProto(const char *proto_name, const wchar_t *username);
+	~WhatsAppProto();
+
+	__forceinline bool isOnline() const
+	{	return m_hServerConn != 0;
+	}
+
+	__forceinline void writeStr(const char *pszSetting, const JSONNode &node)
+	{
+		CMStringW str(node.as_mstring());
+		if (!str.IsEmpty())
+			setWString(pszSetting, str);
+	}
+
+	class CWhatsAppQRDlg *m_pQRDlg;
+
+	// PROTO_INTERFACE /////////////////////////////////////////////////////////////////////
+
+	MCONTACT AddToList(int flags, PROTOSEARCHRESULT *psr) override;
+	INT_PTR  GetCaps(int type, MCONTACT hContact = NULL) override;
+	HANDLE   SearchBasic(const wchar_t* id) override;
+	int      SendMsg(MCONTACT hContact, int flags, const char* msg) override;
+	int      SetStatus(int iNewStatus) override;
+	int      UserIsTyping(MCONTACT hContact, int type) override;
+
+	void     OnModulesLoaded() override;
+
+	// Services ////////////////////////////////////////////////////////////////////////////
+
+	INT_PTR __cdecl SvcCreateAccMgrUI(WPARAM, LPARAM);
+
+	// Events //////////////////////////////////////////////////////////////////////////////
+
+	int __cdecl OnOptionsInit(WPARAM, LPARAM);
+	int __cdecl OnBuildStatusMenu(WPARAM, LPARAM);
+
+	// Options /////////////////////////////////////////////////////////////////////////////
+
+	CMOption<wchar_t*> m_wszNick;				// your nick name in presence
+	CMOption<wchar_t*> m_wszDefaultGroup;  // clist group to store contacts
+	CMOption<bool>     m_bHideGroupchats;  // do not open chat windows on creation
+
+	// Processing Threads //////////////////////////////////////////////////////////////////
+
+	void __cdecl SearchAckThread(void*);
+	void __cdecl ServerThread(void*);
+};
+
+struct CMPlugin : public ACCPROTOPLUGIN<WhatsAppProto>
+{
+	HNETLIBUSER hAvatarUser = nullptr;
+	HNETLIBCONN hAvatarConn = nullptr;
+	bool SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai);
+
+	CMPlugin();
+
+	int Load() override;
+	int Unload() override;
+};
+
+#endif
diff --git a/protocols/WhatsApp/src/qrcode.cpp b/protocols/WhatsApp/src/qrcode.cpp
new file mode 100644
index 0000000000..f38ef2f286
--- /dev/null
+++ b/protocols/WhatsApp/src/qrcode.cpp
@@ -0,0 +1,124 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+class CWhatsAppQRDlg : public CProtoDlgBase<WhatsAppProto>
+{
+public:
+	CWhatsAppQRDlg(WhatsAppProto *ppro) :
+		CProtoDlgBase<WhatsAppProto>(ppro, IDD_SHOWQR)
+	{}
+
+	void SetData(const CMStringA &str)
+	{
+		auto *pQR = QRcode_encodeString(str, 0, QR_ECLEVEL_L, QR_MODE_8, 1);
+
+		HWND hwndRc = GetDlgItem(m_hwnd, IDC_QRPIC);
+		RECT rc;
+		GetClientRect(hwndRc, &rc);
+
+		::SetForegroundWindow(m_hwnd);
+
+		int scale = 8; // (rc.bottom - rc.top) / pQR->width;
+		int rowLen = pQR->width * scale * 3;
+		if (rowLen % 4)
+			rowLen = (rowLen / 4 + 1) * 4;
+		int dataLen = rowLen * pQR->width * scale;
+
+		mir_ptr<BYTE> pData((BYTE *)mir_alloc(dataLen));
+		if (pData == nullptr) {
+			QRcode_free(pQR);
+			return;
+		}
+
+		memset(pData, 0xFF, dataLen); // white background by default
+
+		const BYTE *s = pQR->data;
+		for (int y = 0; y < pQR->width; y++) {
+			BYTE *d = pData.get() + rowLen * y * scale;
+			for (int x = 0; x < pQR->width; x++) {
+				if (*s & 1)
+					for (int i = 0; i < scale; i++)
+						for (int j = 0; j < scale; j++) {
+							d[j * 3 + i * rowLen] = 0;
+							d[1 + j * 3 + i * rowLen] = 0;
+							d[2 + j * 3 + i * rowLen] = 0;
+						}
+
+				d += scale * 3;
+				s++;
+			}
+		}
+
+		BITMAPFILEHEADER fih = {};
+		fih.bfType = 0x4d42;  // "BM"
+		fih.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dataLen;
+		fih.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+
+		BITMAPINFOHEADER bih = {};
+		bih.biSize = sizeof(BITMAPINFOHEADER);
+		bih.biWidth = pQR->width * scale;
+		bih.biHeight = -bih.biWidth;
+		bih.biPlanes = 1;
+		bih.biBitCount = 24;
+		bih.biCompression = BI_RGB;
+
+		wchar_t wszTempPath[MAX_PATH], wszTempFile[MAX_PATH];
+		GetTempPathW(_countof(wszTempPath), wszTempPath);
+		GetTempFileNameW(wszTempPath, L"wa_", TRUE, wszTempFile);
+		FILE *f = _wfopen(wszTempFile, L"wb");
+		fwrite(&fih, sizeof(BITMAPFILEHEADER), 1, f);
+		fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, f);
+		fwrite(pData, sizeof(unsigned char), dataLen, f);
+  		fclose(f);
+
+		SendMessage(hwndRc, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)Image_Load(wszTempFile));
+		
+		DeleteFileW(wszTempFile);
+		QRcode_free(pQR);
+	}
+};
+
+static INT_PTR __stdcall sttShowDialog(void *param)
+{
+	WhatsAppProto *ppro = (WhatsAppProto *)param;
+
+	if (ppro->m_pQRDlg == nullptr) {
+		ppro->m_pQRDlg = new CWhatsAppQRDlg(ppro);
+		ppro->m_pQRDlg->Show();
+	}
+	else {
+		SetForegroundWindow(ppro->m_pQRDlg->GetHwnd());
+		SetActiveWindow(ppro->m_pQRDlg->GetHwnd());
+	}
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::CloseQrDialog()
+{
+	if (m_pQRDlg) {
+		m_pQRDlg->Close();
+		m_pQRDlg = nullptr;
+	}
+}
+
+bool WhatsAppProto::ShowQrCode(const CMStringA &ref)
+{
+	CallFunctionSync(sttShowDialog, this);
+
+	MBinBuffer secret(getBlob(DBKEY_SECRET_KEY));
+
+	ptrA s1(mir_base64_encode(m_noise->noiseKeys.pub));
+	ptrA s2(mir_base64_encode(m_signalStore.signedIdentity.pub));
+	ptrA s3(mir_base64_encode(secret));
+	CMStringA szQrData(FORMAT, "%s,%s,%s,%s", ref.c_str(), s1.get(), s2.get(), s3.get());
+	m_pQRDlg->SetData(szQrData);
+	return true;
+}
diff --git a/protocols/WhatsApp/src/resource.h b/protocols/WhatsApp/src/resource.h
new file mode 100644
index 0000000000..79cce313c0
--- /dev/null
+++ b/protocols/WhatsApp/src/resource.h
@@ -0,0 +1,26 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by W:\miranda-ng\protocols\WhatsApp\res\whatsapp.rc
+//
+#define IDI_WHATSAPP                    100
+#define IDD_ACCMGRUI                    101
+#define IDD_OPTIONS                     102
+#define IDD_SHOWQR                      103
+#define IDC_HIDECHATS                   1000
+#define IDC_DEFGROUP                    1001
+#define IDC_QRPIC                       1002
+#define IDC_DEFGROUP2                   1002
+#define IDC_CLIST                       1003
+#define IDC_NEWJID                      1004
+#define IDC_NICK                        1005
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        104
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1006
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/protocols/WhatsApp/src/server.cpp b/protocols/WhatsApp/src/server.cpp
new file mode 100644
index 0000000000..b61b5d193a
--- /dev/null
+++ b/protocols/WhatsApp/src/server.cpp
@@ -0,0 +1,329 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// gateway worker thread
+
+void WhatsAppProto::ServerThread(void *)
+{
+	do {
+		m_bRespawn = false;
+		ServerThreadWorker();
+	}
+	while (m_bRespawn);
+
+	OnLoggedOut();
+}
+
+void WhatsAppProto::ServerThreadWorker()
+{
+	// connect websocket
+	NETLIBHTTPHEADER hdrs[] =
+	{
+		{ "Origin", "https://web.whatsapp.com" },
+		{ 0, 0 }
+	};
+
+	NLHR_PTR pReply(WebSocket_Connect(m_hNetlibUser, "web.whatsapp.com/ws/chat", hdrs));
+	if (pReply == nullptr) {
+		debugLogA("Server connection failed, exiting");
+		return;
+	}
+
+	if (pReply->resultCode != 101)
+		return;
+
+	delete m_noise;
+	m_noise = new WANoise(this);
+	m_noise->init();
+
+	debugLogA("Server connection succeeded");
+	m_hServerConn = pReply->nlc;
+	m_lastRecvTime = time(0);
+	m_iPacketId = 1;
+
+	Utils_GetRandom(m_wMsgPrefix, sizeof(m_wMsgPrefix));
+
+	auto &pubKey = m_noise->ephemeral.pub;
+	auto *client = new proto::HandshakeMessage::ClientHello(); client->set_ephemeral(pubKey.data(), pubKey.length());
+	proto::HandshakeMessage msg; msg.set_allocated_clienthello(client);
+	WSSend(msg);
+
+	MBinBuffer netbuf;
+
+	for (m_bTerminated = false; !m_bTerminated;) {
+		unsigned char buf[2048];
+		int bufSize = Netlib_Recv(m_hServerConn, (char *)buf, _countof(buf), MSG_NODUMP);
+		if (bufSize == 0) {
+			debugLogA("Gateway connection gracefully closed");
+			break;
+		}
+		if (bufSize < 0) {
+			debugLogA("Gateway connection error, exiting");
+			break;
+		}
+
+		netbuf.append(buf, bufSize);
+
+		WSHeader hdr;
+		if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length()))
+			continue;
+		
+		// we lack some data, let's read them
+		if (netbuf.length() < hdr.headerSize + hdr.payloadSize)
+			if (!WSReadPacket(hdr, netbuf))
+				break;
+
+		// debugLogA("Got packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", 
+		//		netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked);
+		// Netlib_Dump(m_hServerConn, netbuf.data(), netbuf.length(), false, 0);
+
+		m_lastRecvTime = time(0);
+
+		// read all payloads from the current buffer, one by one
+		while (true) {
+			MBinBuffer currPacket;
+			currPacket.assign(netbuf.data() + hdr.headerSize, hdr.payloadSize);
+			
+			switch (hdr.opCode) {
+			case 1: // json packet
+				debugLogA("Text packet, skipping");
+				/*
+					currPacket.append("", 1); // add 0 to use strchr safely
+					CMStringA szJson(pos, (int)dataSize);
+
+					JSONNode root = JSONNode::parse(szJson);
+					if (root) {
+						debugLogA("JSON received:\n%s", start);
+
+						CMStringA szPrefix(start, int(pos - start - 1));
+						auto *pReq = m_arPacketQueue.find((WARequest *)&szPrefix);
+						if (pReq != nullptr) {
+							root << CHAR_PARAM("$id$", szPrefix);
+						}
+					}
+				}
+				*/
+				break;
+
+			case 2: // binary packet
+				if (hdr.payloadSize > 32)
+					ProcessBinaryPacket(currPacket.data(), hdr.payloadSize);
+				break;
+
+			case 8: // close
+				debugLogA("server required to exit");
+				m_bRespawn = m_bTerminated = true; // simply reconnect, don't exit
+				break;
+
+			default:
+				Netlib_Dump(m_hServerConn, currPacket.data(), hdr.payloadSize, false, 0);
+			}
+
+			netbuf.remove(hdr.headerSize + hdr.payloadSize);
+			// debugLogA("%d bytes removed from network buffer, %d bytes remain", hdr.headerSize + hdr.payloadSize, netbuf.length());
+			if (netbuf.length() == 0)
+				break;
+
+			// if we have not enough data for header, continue reading
+			if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length())) {
+				debugLogA("not enough data for header, continue reading");
+				break;
+			}
+
+			// if we have not enough data for data, continue reading
+			if (hdr.headerSize + hdr.payloadSize > netbuf.length()) {
+				debugLogA("not enough place for data (%d+%d > %d), continue reading", hdr.headerSize, hdr.payloadSize, netbuf.length());
+				break;
+			}
+
+			debugLogA("Got inner packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", 
+				netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked);
+		}
+	}
+
+	debugLogA("Server connection dropped");
+	Netlib_CloseHandle(m_hServerConn);
+	m_hServerConn = nullptr;
+}
+
+bool WhatsAppProto::WSReadPacket(const WSHeader &hdr, MBinBuffer &res)
+{
+	size_t currPacketSize = res.length() - hdr.headerSize;
+
+	char buf[1024];
+	while (currPacketSize < hdr.payloadSize) {
+		int result = Netlib_Recv(m_hServerConn, buf, _countof(buf), MSG_NODUMP);
+		if (result == 0) {
+			debugLogA("Gateway connection gracefully closed");
+			return false;
+		}
+		if (result < 0) {
+			debugLogA("Gateway connection error, exiting");
+			return false;
+		}
+
+		currPacketSize += result;
+		res.append(buf, result);
+	}
+	return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Binary data processing
+
+void WhatsAppProto::ProcessBinaryPacket(const void *pData, size_t cbDataLen)
+{
+	while (size_t payloadLen = m_noise->decodeFrame(pData, cbDataLen)) {
+		if (m_noise->bInitFinished) {
+			MBinBuffer buf = m_noise->decrypt(pData, payloadLen);
+
+			WAReader rdr(buf.data(), buf.length());
+			auto b = rdr.readInt8();
+			if (b & 2) {
+				buf.remove(1);
+				buf = unzip(buf);
+				rdr = WAReader(buf.data(), buf.length());
+			}
+
+			if (WANode *pNode = rdr.readNode()) {
+				CMStringA szText;
+				pNode->print(szText);
+				debugLogA("Got binary node:\n%s", szText.c_str());
+
+				auto pHandler = FindPersistentHandler(*pNode);
+				if (pHandler)
+					(this->*pHandler)(*pNode);
+				else
+					debugLogA("cannot handle incoming message");
+
+				delete pNode;
+			}
+			else {
+				debugLogA("wrong or broken payload");
+				Netlib_Dump(m_hServerConn, pData, cbDataLen, false, 0);
+			}
+		}
+		else OnProcessHandshake(pData, (int)payloadLen);
+
+		pData = (BYTE*)pData + payloadLen;
+		cbDataLen -= payloadLen;
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::OnLoggedIn()
+{
+	debugLogA("WhatsAppProto::OnLoggedIn");
+
+	SetServerStatus(m_iDesiredStatus);
+
+	ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, m_iDesiredStatus);
+	m_iStatus = m_iDesiredStatus;
+
+	m_impl.m_keepAlive.Start(1000);
+
+	// retrieve loaded prekeys count
+	WSSendNode(
+		WANodeIq(IQ::GET, "encrypt") << XCHILD("count"),
+		&WhatsAppProto::OnIqCountPrekeys);
+
+	// retrieve initial info
+	WANodeIq abt(IQ::GET, "abt");
+	abt.addChild("props")->addAttr("protocol", "1");
+	WSSendNode(abt, &WhatsAppProto::OnIqDoNothing);
+
+	WSSendNode(
+		WANodeIq(IQ::GET, "w") << XCHILD("props"),
+		&WhatsAppProto::OnIqDoNothing);
+
+	WSSendNode(
+		WANodeIq(IQ::GET, "blocklist"),
+		&WhatsAppProto::OnIqBlockList);
+
+	WSSendNode(
+		WANodeIq(IQ::GET, "privacy") << XCHILD("privacy"),
+		&WhatsAppProto::OnIqDoNothing);
+
+	/*
+	OBJLIST<WACollection> task(1);
+	task.insert(new WACollection("regular_high", 9));
+	task.insert(new WACollection("regular_low", 11));
+	ResyncServer(task);
+	*/
+}
+
+void WhatsAppProto::OnLoggedOut(void)
+{
+	m_impl.m_keepAlive.Stop();
+
+	debugLogA("WhatsAppProto::OnLoggedOut");
+	m_bTerminated = true;
+
+	ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, ID_STATUS_OFFLINE);
+	m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE;
+
+	setAllContactStatuses(ID_STATUS_OFFLINE, false);
+}
+
+void WhatsAppProto::SendKeepAlive()
+{
+	time_t now = time(0);
+	if (now - m_lastRecvTime > 20) {
+		WSSendNode(WANodeIq(IQ::GET, "w:p") << XCHILD("ping"), &WhatsAppProto::OnIqDoNothing);
+
+		m_lastRecvTime = now;
+	}
+}
+
+void WhatsAppProto::SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType)
+{
+	WANode receipt("receipt");
+	receipt << CHAR_PARAM("id", pszId);
+
+	if (!mir_strcmp(pszType, "read") || !mir_strcmp(pszType, "read-self"))
+		receipt << INT_PARAM("t", time(0));
+
+	if (!mir_strcmp(pszType, "sender") && WAJid(pszTo).isUser())
+		receipt << CHAR_PARAM("to", pszParticipant) << CHAR_PARAM("recipient", pszTo);
+	else {
+		receipt << CHAR_PARAM("to", pszTo);
+		if (pszParticipant)
+			receipt << CHAR_PARAM("participant", pszParticipant);
+	}
+
+	if (pszType)
+		receipt << CHAR_PARAM("type", pszType);
+	WSSendNode(receipt, &WhatsAppProto::OnIqDoNothing);
+}
+
+void WhatsAppProto::SetServerStatus(int iStatus)
+{
+	if (mir_wstrlen(m_wszNick))
+		WSSendNode(
+			WANode("presence") << CHAR_PARAM("name", T2Utf(m_wszNick)) << CHAR_PARAM("type", (iStatus == ID_STATUS_ONLINE) ? "available" : "unavailable"),
+			&WhatsAppProto::OnIqDoNothing);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void WhatsAppProto::ShutdownSession()
+{
+	if (m_bTerminated)
+		return;
+
+	debugLogA("WhatsAppProto::ShutdownSession");
+
+	// shutdown all resources
+	if (m_hServerConn)
+		Netlib_Shutdown(m_hServerConn);
+
+	OnLoggedOut();
+}
diff --git a/protocols/WhatsApp/src/signal.cpp b/protocols/WhatsApp/src/signal.cpp
new file mode 100644
index 0000000000..e80eeac4ee
--- /dev/null
+++ b/protocols/WhatsApp/src/signal.cpp
@@ -0,0 +1,529 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// MSignalStore members
+
+static int CompareSessions(const MSignalSession *p1, const MSignalSession *p2)
+{
+	if (int ret = mir_strcmp(p1->szName, p2->szName))
+		return ret;
+	
+	return p1->getDeviceId() - p2->getDeviceId();
+}
+
+MSignalStore::MSignalStore(PROTO_INTERFACE *_1, const char *_2) :
+	pProto(_1),
+	prefix(_2),
+	arSessions(1, &CompareSessions)
+{
+	init();
+}
+
+MSignalStore::~MSignalStore()
+{
+	signal_protocol_store_context_destroy(m_pStore);
+	signal_context_destroy(m_pContext);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static void log_func(int level, const char *pmsg, size_t /*msgLen*/, void *pUserData)
+{
+	auto *pStore = (MSignalStore *)pUserData;
+	pStore->pProto->debugLogA("libsignal {%d}: %s", level, pmsg);
+}
+
+static int hmac_sha256_init(void **hmac_context, const uint8_t *key, size_t key_len, void *)
+{
+	HMAC_CTX *ctx = HMAC_CTX_new();
+	*hmac_context = ctx;
+	HMAC_Init(ctx, key, (int)key_len, EVP_sha256());
+	return 0;
+}
+
+static int hmac_sha256_update(void *hmac_context, const uint8_t *data, size_t data_len, void *)
+{
+	return HMAC_Update((HMAC_CTX *)hmac_context, data, data_len);
+}
+
+static int hmac_sha256_final(void *hmac_context, signal_buffer **output, void *)
+{
+	BYTE data[200];
+	unsigned len = 0;
+	if (!HMAC_Final((HMAC_CTX *)hmac_context, data, &len))
+		return 1;
+
+	*output = signal_buffer_create(data, len);
+	return 0;
+}
+
+static void hmac_sha256_cleanup(void *hmac_context, void *)
+{
+	HMAC_CTX_free((HMAC_CTX *)hmac_context);
+}
+
+static int random_func(uint8_t *pData, size_t size, void *)
+{
+	Utils_GetRandom(pData, size);
+	return 0;
+}
+
+static int decrypt_func(signal_buffer **output,
+	int /*cipher*/,
+	const uint8_t *key, size_t /*key_len*/,
+	const uint8_t *iv, size_t /*iv_len*/,
+	const uint8_t *ciphertext, size_t ciphertext_len,
+	void * /*user_data*/)
+{
+	MBinBuffer res = aesDecrypt(EVP_aes_256_cbc(), key, iv, ciphertext, ciphertext_len);
+	*output = signal_buffer_create(res.data(), res.length());
+	return SG_SUCCESS;
+}
+
+static int contains_session_func(const signal_protocol_address *address, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id);
+	return pStore->arSessions.find(&tmp) == nullptr;
+}
+
+static int delete_all_sessions_func(const char *name, size_t name_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+	auto &pList = pStore->arSessions;
+
+	int count = 0;
+	for (auto &it : pList.rev_iter()) {
+		if (it->hasAddress(name, name_len)) {
+			pList.remove(pList.indexOf(&it));
+			count++;
+		}
+	}
+	return count;
+}
+
+int delete_session_func(const signal_protocol_address *address, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+	auto &pList = pStore->arSessions;
+
+	MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id);
+	int idx = pList.getIndex(&tmp);
+	if (idx != -1)
+		pList.remove(idx);
+	return 0;
+}
+
+static int get_sub_device_sessions_func(signal_int_list **sessions, const char *name, size_t name_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+	CMStringA szName(name, (int)name_len);
+
+	signal_int_list *l = signal_int_list_alloc();
+	unsigned int array_size = 0;
+
+	for (auto &it : pStore->arSessions)
+		if (it->szName == szName) {
+			array_size++;
+			signal_int_list_push_back(l, it->getDeviceId());
+		}
+
+	*sessions = l;
+	return array_size;
+}
+
+static void destroy_func(void *)
+{}
+
+int load_session_func(signal_buffer **record, signal_buffer **user_data_storage, const signal_protocol_address *address, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id);
+	if (auto *pSession = pStore->arSessions.find(&tmp)) {
+		*record = signal_buffer_create((uint8_t *)pSession->sessionData.data(), pSession->sessionData.length());
+		*user_data_storage = signal_buffer_create((uint8_t *)pSession->userData.data(), pSession->userData.length());
+		return 1;
+	}
+
+	return 0;
+}
+
+static int store_session_func(const signal_protocol_address *address, uint8_t *record, size_t record_len, uint8_t *user_record, size_t user_record_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id);
+	auto *pSession = pStore->arSessions.find(&tmp);
+	if (pSession == nullptr) {
+		pSession = new MSignalSession(tmp);
+		pStore->arSessions.insert(pSession);
+	}
+
+	pSession->sessionData.assign(record, record_len);
+	pSession->userData.assign(user_record, user_record_len);
+	return 0;
+}
+
+static int contains_pre_key(uint32_t pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id);
+	MBinBuffer blob(pStore->pProto->getBlob(szSetting));
+	return (blob.data() != 0);
+}
+
+static int load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id);
+	MBinBuffer blob(pStore->pProto->getBlob(szSetting));
+	if (blob.data() == 0)
+		return SG_ERR_INVALID_KEY_ID;
+
+	*record = signal_buffer_create((uint8_t *)blob.data(), blob.length());
+	return SG_SUCCESS; //key exists and succesfully loaded
+}
+
+static int remove_pre_key(uint32_t pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id);
+	pStore->pProto->delSetting(szSetting);
+
+	szSetting.Format("PreKey%uPublic", pre_key_id);
+	pStore->pProto->delSetting(szSetting);
+
+	szSetting.Format("PreKey%uPrivate", pre_key_id);
+	pStore->pProto->delSetting(szSetting);
+	return 0;
+}
+
+static int store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id);
+	db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len);
+
+	session_pre_key *prekey = nullptr;
+	session_pre_key_deserialize(&prekey, record, record_len, pStore->CTX()); //TODO: handle error
+	if (prekey) {
+		ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(prekey);
+
+		SignalBuffer key_buf(ec_key_pair_get_public(pre_key_pair));
+		szSetting.Format("PreKey%uPublic", pre_key_id);
+		db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_buf.data(), key_buf.len());
+	}
+
+	return 0;
+}
+
+static int contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id);
+	MBinBuffer blob(pStore->pProto->getBlob(szSetting));
+	return blob.data() != 0;
+}
+
+static int load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id);
+	MBinBuffer blob(pStore->pProto->getBlob(szSetting));
+	if (blob.data() == 0)
+		return SG_ERR_INVALID_KEY_ID;
+
+	*record = signal_buffer_create(blob.data(), blob.length());
+	return SG_SUCCESS; //key exist and succesfully loaded
+}
+
+static int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, size_t record_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id);
+	db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len);
+	return 0;
+}
+
+static int remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id);
+	pStore->pProto->delSetting(szSetting);
+	return 0;
+}
+
+static int get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	MBinBuffer buf;
+	buf.append(KEY_BUNDLE_TYPE, 1);
+	buf.append(pStore->signedIdentity.pub);
+	*public_data = signal_buffer_create(buf.data(), (int)buf.length());
+
+	*private_data = signal_buffer_create((uint8_t *)pStore->signedIdentity.priv.data(), (int)pStore->signedIdentity.priv.length());
+	return 0;
+}
+
+static int get_local_registration_id(void *user_data, uint32_t *registration_id)
+{
+	auto *pStore = (MSignalStore *)user_data;
+	*registration_id = pStore->pProto->getDword(DBKEY_REG_ID);
+	return 0;
+}
+
+static int save_identity(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data)
+{
+	auto *pStore = (MSignalStore *)user_data;
+
+	CMStringA szSetting(FORMAT, "%s_%s_%d", "SignalIdentity", CMStringA(address->name, (int)address->name_len).c_str(), address->device_id);
+	if (key_data != nullptr)
+		db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_data, (unsigned int)key_len); //TODO: check return value
+	else
+		pStore->pProto->delSetting(szSetting);
+	return 0;
+}
+
+static int is_trusted_identity(const signal_protocol_address * /*address*/, uint8_t * /*key_data*/, size_t /*key_len*/, void * /*user_data*/)
+{
+	return 1;
+}
+
+void MSignalStore::init()
+{
+	signal_context_create(&m_pContext, this);
+	signal_context_set_log_function(m_pContext, log_func);
+
+	signal_crypto_provider prov;
+	memset(&prov, 0xFF, sizeof(prov));
+	prov.hmac_sha256_init_func = hmac_sha256_init;
+	prov.hmac_sha256_final_func = hmac_sha256_final;
+	prov.hmac_sha256_update_func = hmac_sha256_update;
+	prov.hmac_sha256_cleanup_func = hmac_sha256_cleanup;
+	prov.random_func = random_func;
+	prov.decrypt_func = decrypt_func;
+	signal_context_set_crypto_provider(m_pContext, &prov);
+
+	// default values calculation
+	if (pProto->getDword(DBKEY_PREKEY_NEXT_ID, 0xFFFF) == 0xFFFF) {
+		// generate signed identity keys (private & public)
+		ratchet_identity_key_pair *keyPair;
+		signal_protocol_key_helper_generate_identity_key_pair(&keyPair, m_pContext);
+
+		auto *pPubKey = ratchet_identity_key_pair_get_public(keyPair);
+		db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PUB, pPubKey->data, sizeof(pPubKey->data));
+
+		auto *pPrivKey = ratchet_identity_key_pair_get_private(keyPair);
+		db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PRIV, pPrivKey->data, sizeof(pPrivKey->data));
+
+		session_signed_pre_key *signed_pre_key;
+		signal_protocol_key_helper_generate_signed_pre_key(&signed_pre_key, keyPair, 1, time(0), m_pContext);
+
+		SignalBuffer prekeyBuf(signed_pre_key);
+		db_set_blob(0, pProto->m_szModuleName, DBKEY_PREKEY, prekeyBuf.data(), prekeyBuf.len());
+		SIGNAL_UNREF(signed_pre_key);
+		SIGNAL_UNREF(keyPair);
+	}
+
+	// read resident data from database
+	signedIdentity.pub = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PUB);
+	signedIdentity.priv = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PRIV);
+
+	MBinBuffer blob(pProto->getBlob(DBKEY_PREKEY));
+	session_signed_pre_key *signed_pre_key;
+	session_signed_pre_key_deserialize(&signed_pre_key, blob.data(), blob.length(), m_pContext);
+
+	ec_key_pair *pKeys = session_signed_pre_key_get_key_pair(signed_pre_key);
+	auto *pPubKey = ec_key_pair_get_public(pKeys);
+	preKey.pub.assign(pPubKey->data, sizeof(pPubKey->data));
+
+	auto *pPrivKey = ec_key_pair_get_private(pKeys);
+	preKey.priv.assign(pPrivKey->data, sizeof(pPrivKey->data));
+
+	preKey.signature.assign(session_signed_pre_key_get_signature(signed_pre_key), session_signed_pre_key_get_signature_len(signed_pre_key));
+	preKey.keyid = session_signed_pre_key_get_id(signed_pre_key);
+	SIGNAL_UNREF(signed_pre_key);
+
+	// create store with callbacks
+	signal_protocol_store_context_create(&m_pStore, m_pContext);
+
+	signal_protocol_session_store ss;
+	ss.contains_session_func = &contains_session_func;
+	ss.delete_all_sessions_func = &delete_all_sessions_func;
+	ss.delete_session_func = &delete_session_func;
+	ss.destroy_func = &destroy_func;
+	ss.get_sub_device_sessions_func = &get_sub_device_sessions_func;
+	ss.load_session_func = &load_session_func;
+	ss.store_session_func = &store_session_func;
+	ss.user_data = this;
+	signal_protocol_store_context_set_session_store(m_pStore, &ss);
+
+	signal_protocol_pre_key_store sp;
+	sp.contains_pre_key = &contains_pre_key;
+	sp.destroy_func = &destroy_func;
+	sp.load_pre_key = &load_pre_key;
+	sp.remove_pre_key = &remove_pre_key;
+	sp.store_pre_key = &store_pre_key;
+	sp.user_data = this;
+	signal_protocol_store_context_set_pre_key_store(m_pStore, &sp);
+
+	signal_protocol_signed_pre_key_store ssp;
+	ssp.contains_signed_pre_key = &contains_signed_pre_key;
+	ssp.destroy_func = &destroy_func;
+	ssp.load_signed_pre_key = &load_signed_pre_key;
+	ssp.remove_signed_pre_key = &remove_signed_pre_key;
+	ssp.store_signed_pre_key = &store_signed_pre_key;
+	ssp.user_data = this;
+	signal_protocol_store_context_set_signed_pre_key_store(m_pStore, &ssp);
+
+	signal_protocol_identity_key_store sip;
+	sip.destroy_func = &destroy_func;
+	sip.get_identity_key_pair = &get_identity_key_pair;
+	sip.get_local_registration_id = &get_local_registration_id;
+	sip.is_trusted_identity = &is_trusted_identity;
+	sip.save_identity = &save_identity;
+	sip.user_data = this;
+	signal_protocol_store_context_set_identity_key_store(m_pStore, &sip);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// MSignalSession members
+
+MSignalSession::MSignalSession(const CMStringA &_1, int _2) :
+	szName(_1)
+{
+	address.name = szName.GetBuffer();
+	address.name_len = szName.GetLength();
+	address.device_id = _2;
+}
+
+MSignalSession::~MSignalSession()
+{
+	session_cipher_free(cipher);
+}
+
+bool MSignalSession::hasAddress(const char *name, size_t name_len) const
+{
+	if (address.name_len != name_len)
+		return false;
+	return memcmp(address.name, name, name_len) == 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+MSignalSession* MSignalStore::createSession(const CMStringA &szName, int deviceId)
+{
+	MSignalSession tmp(szName, deviceId);
+	auto *pSession = arSessions.find(&tmp);
+	if (pSession == nullptr) {
+		pSession = new MSignalSession(szName, deviceId);
+		arSessions.insert(pSession);
+	}
+
+	if (pSession->cipher == nullptr)
+		if (session_cipher_create(&pSession->cipher, m_pStore, &pSession->address, m_pContext) < 0)
+			throw "session_cipher_create failure";
+
+	return pSession;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+signal_buffer* MSignalStore::decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted)
+{
+	WAJid jid(from);
+	auto *pSession = createSession(jid.user, 0);
+
+	signal_buffer *result = nullptr;
+	if (!mir_strcmp(pszType, "pkmsg")) {
+		pre_key_signal_message *pMsg; 
+		if (pre_key_signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0)
+			throw "unable to deserialize prekey message";
+
+		if (session_cipher_decrypt_pre_key_signal_message(pSession->getCipher(), pMsg, this, &result) < 0)
+			throw "unable to decrypt prekey message";
+
+		pre_key_signal_message_destroy((signal_type_base*)pMsg);
+	}
+	else {
+		signal_message *pMsg;
+		if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0)
+			throw "unable to deserialize signal message";
+
+		if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0)
+			throw "unable to decrypt signal message";
+
+		signal_message_destroy((signal_type_base *)pMsg);
+	}
+
+	return result;
+}
+
+signal_buffer* MSignalStore::decryptGroupSignalProto(const CMStringA &group, const CMStringA &sender, const MBinBuffer &encrypted)
+{
+	WAJid jid(sender);
+	auto *pSession = createSession(group + CMStringA(FORMAT, "::%s::%d", jid.user.c_str(), jid.device), 0);
+
+	signal_message *pMsg;
+	if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0)
+		throw "unable to deserialize signal message";
+
+	signal_buffer *result = nullptr;
+	if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0)
+		throw "unable to decrypt signal message";
+
+	signal_message_destroy((signal_type_base *)pMsg);
+	return result;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// generate and save pre keys set
+
+void MSignalStore::generatePrekeys(int count)
+{
+	int iNextKeyId = pProto->getDword(DBKEY_PREKEY_NEXT_ID, 1);
+
+	CMStringA szSetting;
+	signal_protocol_key_helper_pre_key_list_node *keys_root;
+	signal_protocol_key_helper_generate_pre_keys(&keys_root, iNextKeyId, count, m_pContext);
+	for (auto *it = keys_root; it; it = signal_protocol_key_helper_key_list_next(it)) {
+		session_pre_key *pre_key = signal_protocol_key_helper_key_list_element(it);
+		uint32_t pre_key_id = session_pre_key_get_id(pre_key);
+
+		SignalBuffer buf(pre_key);
+		szSetting.Format("PreKey%d", pre_key_id);
+		db_set_blob(0, pProto->m_szModuleName, szSetting, buf.data(), buf.len());
+
+		ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(pre_key);
+		auto *pPubKey = ec_key_pair_get_public(pre_key_pair);
+		szSetting.Format("PreKey%dPublic", pre_key_id);
+		db_set_blob(0, pProto->m_szModuleName, szSetting, pPubKey->data, sizeof(pPubKey->data));
+	}
+	signal_protocol_key_helper_key_list_free(keys_root);
+
+	pProto->setDword(DBKEY_PREKEY_NEXT_ID, iNextKeyId + count);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void MSignalStore::processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &)
+{
+}
diff --git a/protocols/WhatsApp/src/stdafx.cxx b/protocols/WhatsApp/src/stdafx.cxx
new file mode 100644
index 0000000000..7942e82b45
--- /dev/null
+++ b/protocols/WhatsApp/src/stdafx.cxx
@@ -0,0 +1,8 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
diff --git a/protocols/WhatsApp/src/stdafx.h b/protocols/WhatsApp/src/stdafx.h
new file mode 100644
index 0000000000..80d130a5ec
--- /dev/null
+++ b/protocols/WhatsApp/src/stdafx.h
@@ -0,0 +1,81 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#pragma once
+#pragma warning(disable:4996 4290 4200 4239 4324)
+
+#include <fcntl.h>
+#include <malloc.h>
+#include <io.h>
+#include <time.h>
+#include <windows.h>
+
+#include <list>
+#include <string>
+
+#include <newpluginapi.h>
+#include <m_avatars.h>
+#include <m_chat_int.h>
+#include <m_clist.h>
+#include <m_contacts.h>
+#include <m_database.h>
+#include <m_history.h>
+#include <m_imgsrvc.h>
+#include <m_ignore.h>
+#include <m_json.h>
+#include <m_langpack.h>
+#include <m_message.h>
+#include <m_netlib.h>
+#include <m_options.h>
+#include <m_popup.h>
+#include <m_protocols.h>
+#include <m_protosvc.h>
+#include <m_protoint.h>
+#include <m_skin.h>
+#include <m_string.h>
+#include <statusmodes.h>
+#include <m_userinfo.h>
+#include <m_icolib.h>
+#include <m_utils.h>
+#include <m_xml.h>
+#include <m_hotkeys.h>
+#include <m_folders.h>
+#include <m_json.h>
+#include <m_gui.h>
+
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <openssl/sha.h>
+#include <openssl/kdf.h>
+
+#include "../../libs/libqrencode/src/qrencode.h"
+#include "../../libs/zlib/src/zlib.h"
+
+#include "../../utils/mir_signal.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// to obtain protobuf library do the following
+// - install vcpkg (https://github.com/microsoft/vcpkg);
+// - integrage vcpkg into Visual Studio:
+// >vcpkg.exe integrate install
+// - install dynamic libraries of protobuf:
+// >vcpkg.exe install protobuf:x86-windows
+// >vcpkg.exe install protobuf:x64-windows
+
+#include "google/protobuf/message.h"
+#include "pmsg.pb.h"
+
+using namespace google::protobuf;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+#include "db.h"
+#include "utils.h"
+#include "proto.h"
+#include "resource.h"
+
+#pragma comment(lib, "libcrypto.lib")
diff --git a/protocols/WhatsApp/src/utils.cpp b/protocols/WhatsApp/src/utils.cpp
new file mode 100644
index 0000000000..debfa43f42
--- /dev/null
+++ b/protocols/WhatsApp/src/utils.cpp
@@ -0,0 +1,373 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+
+WAJid::WAJid(const char *pszUser, const char *pszServer, int iDevice, int iAgent) :
+	user(pszUser ? pszUser : ""),
+	server(pszServer ? pszServer : ""),
+	device(iDevice),
+	agent(iAgent)
+{}
+
+WAJid::WAJid(const char *pszJid)
+{
+	if (pszJid == nullptr)
+		pszJid = "";
+
+	auto *tmp = NEWSTR_ALLOCA(pszJid);
+	auto *p = strrchr(tmp, '@');
+	if (p) {
+		*p = 0;
+		server = p + 1;
+	}
+
+	if (p = strrchr(tmp, ':')) {
+		*p = 0;
+		device = atoi(p + 1);
+	}
+	else device = 0;
+
+	if (p = strrchr(tmp, '_')) {
+		*p = 0;
+		agent = atoi(p + 1);
+	}
+	else agent = 0;
+
+	user = tmp;
+}
+
+bool WAJid::isUser() const
+{	return server == "s.whatsapp.net";
+}
+
+bool WAJid::isGroup() const
+{	return server == "g.us";
+}
+
+bool WAJid::isBroadcast() const
+{
+	return server == "broadcast";
+}
+
+bool WAJid::isStatusBroadcast() const
+{
+	return isBroadcast() && user == "status";
+}
+
+CMStringA WAJid::toString() const
+{
+	CMStringA ret(user);
+	if (agent > 0)
+		ret.AppendFormat("_%d", agent);
+	if (device > 0)
+		ret.AppendFormat(":%d", device);
+	ret.AppendFormat("@%s", server.c_str());
+	return ret;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+WAUser* WhatsAppProto::FindUser(const char *szId)
+{
+	mir_cslock lck(m_csUsers);
+	auto *tmp = (WAUser *)_alloca(sizeof(WAUser));
+	tmp->szId = (char*)szId;
+	return m_arUsers.find(tmp);
+}
+
+WAUser* WhatsAppProto::AddUser(const char *szId, bool bTemporary, bool isChat)
+{
+	auto *pUser = FindUser(szId);
+	if (pUser != nullptr)
+		return pUser;
+
+	MCONTACT hContact = db_add_contact();
+	Proto_AddToContact(hContact, m_szModuleName);
+
+	if (isChat) {
+		setByte(hContact, "ChatRoom", 1);
+		setString(hContact, "ChatRoomID", szId);
+	}
+	else {
+		setString(hContact, DBKEY_JID, szId);
+		if (m_wszDefaultGroup)
+			Clist_SetGroup(hContact, m_wszDefaultGroup);
+	}
+
+	if (bTemporary)
+		Contact::RemoveFromList(hContact);
+
+	pUser = new WAUser(hContact, mir_strdup(szId));
+	pUser->bIsGroupChat = isChat;
+
+	mir_cslock lck(m_csUsers);
+	m_arUsers.insert(pUser);
+	return pUser;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+WA_PKT_HANDLER WhatsAppProto::FindPersistentHandler(const WANode &pNode)
+{
+	auto *pChild = pNode.getFirstChild();
+	CMStringA szChild = (pChild) ? pChild->title : "";
+	CMStringA szTitle = pNode.title;
+	CMStringA szType = pNode.getAttr("type");
+	CMStringA szXmlns = pNode.getAttr("xmlns");
+
+	for (auto &it : m_arPersistent) {
+		if (it->pszTitle && szTitle != it->pszTitle)
+			continue;
+		if (it->pszType && szType != it->pszType)
+			continue;
+		if (it->pszXmlns && szXmlns != it->pszXmlns)
+			continue;
+		if (it->pszChild && szChild != it->pszChild)
+			continue;
+		return it->pHandler;
+	}
+
+	return nullptr;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+CMStringA WhatsAppProto::GenerateMessageId()
+{
+	return CMStringA(FORMAT, "%d.%d-%d", m_wMsgPrefix[0], m_wMsgPrefix[1], m_iPacketId++);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// sends a piece of JSON to a server via a websocket, masked
+
+int WhatsAppProto::WSSend(const MessageLite &msg)
+{
+	if (m_hServerConn == nullptr)
+		return -1;
+
+	int cbLen = msg.ByteSize();
+	ptrA protoBuf((char *)mir_alloc(cbLen));
+	msg.SerializeToArray(protoBuf, cbLen);
+
+	Netlib_Dump(m_hServerConn, protoBuf, cbLen, true, 0);
+
+	MBinBuffer payload = m_noise->encodeFrame(protoBuf, cbLen);
+	WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length());
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static char zeroData[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+int WhatsAppProto::WSSendNode(WANode &node, WA_PKT_HANDLER pHandler)
+{
+	if (m_hServerConn == nullptr)
+		return 0;
+
+	if (pHandler != nullptr) {
+		CMStringA id(GenerateMessageId());
+		node.addAttr("id", id);
+
+		mir_cslock lck(m_csPacketQueue);
+		m_arPacketQueue.insert(new WARequest(id, pHandler));
+	}
+
+	CMStringA szText;
+	node.print(szText);
+	debugLogA("Sending binary node:\n%s", szText.c_str());
+
+	WAWriter writer;
+	writer.writeNode(&node);
+
+	MBinBuffer encData = m_noise->encrypt(writer.body.data(), writer.body.length());
+	MBinBuffer payload = m_noise->encodeFrame(encData.data(), encData.length());
+	WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length());
+	return 1;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+uint32_t decodeBigEndian(const std::string &buf)
+{
+	uint32_t ret = 0;
+	for (auto &cc : buf) {
+		ret <<= 8;
+		ret += (uint8_t)cc;
+	}
+
+	return ret;
+}
+
+std::string encodeBigEndian(uint32_t num, size_t len)
+{
+	std::string res;
+	for (int i = 0; i < len; i++) {
+		char c = num & 0xFF;
+		res = c + res;
+		num >>= 8;
+	}
+	return res;
+}
+
+void generateIV(uint8_t *iv, int &pVar)
+{
+	auto counter = encodeBigEndian(pVar);
+	memset(iv, 0, sizeof(iv));
+	memcpy(iv + 8, counter.c_str(), sizeof(int));
+	
+	pVar++;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Popups
+
+void WhatsAppProto::InitPopups(void)
+{
+	g_plugin.addPopupOption(CMStringW(FORMAT, TranslateT("%s error notifications"), m_tszUserName), m_bUsePopups);
+
+	char name[256];
+	mir_snprintf(name, "%s_%s", m_szModuleName, "Error");
+
+	wchar_t desc[256];
+	mir_snwprintf(desc, L"%s/%s", m_tszUserName, TranslateT("Errors"));
+
+	POPUPCLASS ppc = {};
+	ppc.flags = PCF_UNICODE;
+	ppc.pszName = name;
+	ppc.pszDescription.w = desc;
+	ppc.hIcon = IcoLib_GetIconByHandle(m_hProtoIcon);
+	ppc.colorBack = RGB(191, 0, 0); //Red
+	ppc.colorText = RGB(255, 245, 225); //Yellow
+	ppc.iSeconds = 60;
+	m_hPopupClass = Popup_RegisterClass(&ppc);
+
+	IcoLib_ReleaseIcon(ppc.hIcon);
+}
+
+void WhatsAppProto::Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle)
+{
+	if (!m_bUsePopups)
+		return;
+
+	char name[256];
+	mir_snprintf(name, "%s_%s", m_szModuleName, "Error");
+
+	CMStringW wszTitle(szTitle);
+	if (hContact == 0) {
+		wszTitle.Insert(0, L": ");
+		wszTitle.Insert(0, m_tszUserName);
+	}
+
+	POPUPDATACLASS ppd = {};
+	ppd.szTitle.w = wszTitle;
+	ppd.szText.w = szMsg;
+	ppd.pszClassName = name;
+	ppd.hContact = hContact;
+	Popup_AddClass(&ppd);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+MBinBuffer WhatsAppProto::unzip(const MBinBuffer &src)
+{
+	z_stream strm = {};
+	inflateInit(&strm);
+
+	strm.avail_in = (uInt)src.length();
+	strm.next_in = (Bytef *)src.data();
+
+	MBinBuffer res;
+	Bytef buf[2048];
+
+	while (strm.avail_in > 0) {
+		strm.avail_out = sizeof(buf);
+		strm.next_out = buf;
+
+		int ret = inflate(&strm, Z_NO_FLUSH);
+		switch (ret) {
+		case Z_NEED_DICT:
+			ret = Z_DATA_ERROR;
+			__fallthrough;
+
+		case Z_DATA_ERROR:
+		case Z_MEM_ERROR:
+			inflateEnd(&strm);
+			return res;
+		}
+
+		res.append(buf, sizeof(buf) - strm.avail_out);
+	}
+
+	inflateEnd(&strm);
+	return res;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName)
+{
+	int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE);
+	if (fileId != -1) {
+		write(fileId, buf.data(), (unsigned)buf.length());
+		close(fileId);
+	}
+}
+
+void string2file(const std::string &str, const wchar_t *pwszFileName)
+{
+	int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE);
+	if (fileId != -1) {
+		write(fileId, str.c_str(), (unsigned)str.size());
+		close(fileId);
+	}
+}
+
+CMStringA directPath2url(const char *pszDirectPath)
+{
+	return CMStringA("https://mmg.whatsapp.net") + pszDirectPath;
+}
+
+MBinBuffer WhatsAppProto::DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszMediaType)
+{
+	NETLIBHTTPHEADER headers[1] = {{"Origin", "https://web.whatsapp.com"}};
+
+	NETLIBHTTPREQUEST req = {};
+	req.cbSize = sizeof(req);
+	req.requestType = REQUEST_GET;
+	req.szUrl = (char*)url;
+	req.headersCount = _countof(headers);
+	req.headers = headers;
+
+	MBinBuffer ret;
+	auto *pResp = Netlib_HttpTransaction(m_hNetlibUser, &req);
+	if (pResp) {
+		if (pResp->resultCode == 200) {
+			CMStringA pszHkdfString = pszMediaType;
+			pszHkdfString.SetAt(_toupper(pszHkdfString[0]), 0);
+			pszHkdfString = "WhatsApp " + pszHkdfString + " Keys";
+
+			// 0 - 15: iv
+			// 16 - 47: cipherKey
+			// 48 - 111: macKey
+			uint8_t out[112];
+			HKDF(EVP_sha256(), (BYTE *)"", 0, (BYTE *)mediaKeys.c_str(), (int)mediaKeys.size(), (BYTE *)pszHkdfString.c_str(), pszHkdfString.GetLength(), out, sizeof(out));
+
+			ret = aesDecrypt(EVP_aes_256_cbc(), out + 16, out, pResp->pData, pResp->dataLength);
+		}
+	}
+
+	return ret;
+}
+
+CMStringW WhatsAppProto::GetTmpFileName(const char *pszClass, const char *pszAddition)
+{
+	CMStringW ret(VARSW(L"%miranda_userdata%"));
+	ret.AppendFormat(L"/%S/%S_%S", m_szModuleName, pszClass, pszAddition);
+	return ret;
+}
diff --git a/protocols/WhatsApp/src/utils.h b/protocols/WhatsApp/src/utils.h
new file mode 100644
index 0000000000..778732e312
--- /dev/null
+++ b/protocols/WhatsApp/src/utils.h
@@ -0,0 +1,199 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#define DICT_VERSION 2
+
+#define LIST_EMPTY   0
+#define STREAM_END   2
+#define DICTIONARY_0 236
+#define DICTIONARY_1 237
+#define DICTIONARY_2 238
+#define DICTIONARY_3 239
+#define AD_JID       247
+#define LIST_8       248
+#define LIST_16      249
+#define JID_PAIR     250
+#define HEX_8        251
+#define BINARY_8     252
+#define BINARY_20    253
+#define BINARY_32    254
+#define NIBBLE_8     255
+
+class WANode // kinda XML
+{
+	friend class WAReader;
+	friend class WAWriter;
+
+	WANode *pParent = nullptr;
+	OBJLIST<struct Attr> attrs;
+	OBJLIST<WANode> children;
+
+public:
+	WANode();
+	WANode(const char *pszTitle);
+	~WANode();
+
+	void addAttr(const char *pszName, const char *pszValue);
+	void addAttr(const char *pszName, int iValue);
+	int getAttrInt(const char *pszName) const;
+	const char *getAttr(const char *pszName) const;
+
+	CMStringA getBody() const;
+
+	WANode *addChild(const char *pszName);
+	WANode *getChild(const char *pszName) const;
+	WANode *getFirstChild(void) const;
+	const OBJLIST<WANode> &getChildren(void) const
+	{	return children;
+	}
+
+	void print(CMStringA &dest, int level = 0) const;
+
+	CMStringA title;
+	MBinBuffer content;
+};
+
+__forceinline WANode &operator<<(WANode &node, const CHAR_PARAM &param)
+{
+	node.addAttr(param.szName, param.szValue);
+	return node;
+}
+
+__forceinline WANode &operator<<(WANode &node, const INT_PARAM &param)
+{
+	node.addAttr(param.szName, param.iValue);
+	return node;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+namespace IQ
+{
+	enum Type { GET, SET, RESULT };
+};
+
+struct WANodeIq : public WANode
+{
+	WANodeIq(IQ::Type type, const char *pszXmlns = nullptr, const char *pszTo = nullptr);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+struct XCHILD
+{
+	const char *name, *value;
+
+	__forceinline XCHILD(const char *_name) :
+		name(_name)
+	{}
+};
+
+__forceinline WANode& operator<<(WANode &node, const XCHILD &child)
+{
+	node.addChild(child.name);
+	return node;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WAReader
+
+class WAReader
+{
+	const BYTE *m_buf, *m_limit;
+
+	uint32_t readIntN(int i);
+	CMStringA readStringFromChars(int size);
+
+	bool      readAttributes(WANode *node, int count);
+	uint32_t  readInt20();
+	bool      readList(WANode *pParent, int tag);
+	int       readListSize(int tag);
+	CMStringA readPacked(int tag);
+	CMStringA readString(int tag);
+
+public:
+	WAReader(const void *buf, size_t cbLen) :
+		m_buf((BYTE*)buf),
+		m_limit((BYTE*)buf + cbLen)
+	{}
+
+	WANode* readNode();
+
+	__forceinline uint32_t readInt8() { return readIntN(1); }
+	__forceinline uint32_t readInt16() { return readIntN(2); }
+	__forceinline uint32_t readInt32() { return readIntN(4); }
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WAWriter
+
+class WAWriter
+{
+	__forceinline void writeInt8(int value) { writeIntN(value, 1); }
+	__forceinline void writeInt16(int value) { writeIntN(value, 2); }
+	__forceinline void writeInt32(int value) { writeIntN(value, 4); }
+
+	void writeByte(uint8_t b);
+	void writeIntN(int value, int i);
+	void writeInt20(int value);
+	void writeLength(int value);
+	void writeListSize(int tag);
+	void writePacked(const CMStringA &str, int tag);
+	void writeString(const char *str);
+	bool writeToken(const char *str);
+
+public:
+	void writeNode(const WANode *pNode);
+
+	MBinBuffer body;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+struct WAJid
+{
+	int device, agent;
+	CMStringA user, server;
+
+	WAJid(const char *pszJid);
+	WAJid(const char *pszUser, const char *pszServer, int device = 0, int agent = 0);
+
+	CMStringA toString() const;
+
+	bool isUser() const;
+	bool isGroup() const;
+	bool isBroadcast() const;
+	bool isStatusBroadcast() const;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName);
+void string2file(const std::string &str, const wchar_t *pwszFileName);
+CMStringA directPath2url(const char *pszDirectPath);
+
+MBinBuffer aesDecrypt(
+	const EVP_CIPHER *cipher,
+	const uint8_t *key,
+	const uint8_t *iv,
+	const void *data, size_t dataLen,
+	const void *additionalData = 0, size_t additionalLen = 0);
+
+uint32_t    decodeBigEndian(const std::string &buf);
+std::string encodeBigEndian(uint32_t num, size_t len = sizeof(uint32_t));
+
+void generateIV(uint8_t *iv, int &pVar);
+
+__forceinline bool operator<<(MessageLite &msg, const MBinBuffer &buf)
+{	return msg.ParseFromArray(buf.data(), (int)buf.length());
+}
+
+unsigned char* HKDF(const EVP_MD *evp_md,
+	const unsigned char *salt, size_t salt_len,
+	const unsigned char *key, size_t key_len,
+	const unsigned char *info, size_t info_len,
+	unsigned char *okm, size_t okm_len);
diff --git a/protocols/WhatsApp/src/version.h b/protocols/WhatsApp/src/version.h
new file mode 100644
index 0000000000..18e50dd07e
--- /dev/null
+++ b/protocols/WhatsApp/src/version.h
@@ -0,0 +1,14 @@
+#define __MAJOR_VERSION          0
+#define __MINOR_VERSION          0
+#define __RELEASE_NUM            1
+#define __BUILD_NUM              1
+
+#include <stdver.h>
+
+#define __PLUGIN_NAME            "WhatsApp protocol"
+#define __FILENAME               "WhatsApp.dll"
+#define __DESCRIPTION            "WhatsApp protocol support for Miranda NG."
+#define __AUTHOR                 "George Hazan"
+#define __AUTHOREMAIL            ""
+#define __AUTHORWEB              "https://miranda-ng.org/p/WhatsApp/"
+#define __COPYRIGHT              "© 2019-22 Miranda NG Team"
diff --git a/protocols/WhatsApp/src/wanode.cpp b/protocols/WhatsApp/src/wanode.cpp
new file mode 100644
index 0000000000..cbe9408f20
--- /dev/null
+++ b/protocols/WhatsApp/src/wanode.cpp
@@ -0,0 +1,599 @@
+/*
+
+WhatsApp plugin for Miranda NG
+Copyright © 2019-22 George Hazan
+
+*/
+
+#include "stdafx.h"
+#include "dicts.h"
+
+struct Attr
+{
+	Attr(const char *pszName, const char *pszValue) :
+		name(pszName),
+		value(pszValue)
+	{}
+
+	Attr(const char *pszName, int iValue) :
+		name(pszName),
+		value(FORMAT, "%d", iValue)
+	{}
+
+	CMStringA name, value;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WANodeIq members
+
+WANodeIq::WANodeIq(IQ::Type type, const char *pszXmlns, const char *pszTo) :
+	WANode("iq")
+{
+	switch (type) {
+	case IQ::GET: addAttr("type", "get"); break;
+	case IQ::SET: addAttr("type", "set"); break;
+	case IQ::RESULT: addAttr("type", "result"); break;
+	}
+
+	if (pszXmlns)
+		addAttr("xmlns", pszXmlns);
+
+	addAttr("to", pszTo ? pszTo : S_WHATSAPP_NET);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WANode members
+
+WANode::WANode() :
+	attrs(1),
+	children(1)
+{}
+
+WANode::WANode(const char *pszTitle) :
+	attrs(1),
+	children(1),
+	title(pszTitle)
+{}
+
+WANode::~WANode()
+{
+}
+
+const char *WANode::getAttr(const char *pszName) const
+{
+	if (this != nullptr)
+		for (auto &p : attrs)
+			if (p->name == pszName)
+				return p->value.c_str();
+
+	return nullptr;
+}
+
+int WANode::getAttrInt(const char *pszName) const
+{
+	if (this != nullptr)
+		for (auto &p : attrs)
+			if (p->name == pszName)
+				return atoi(p->value.c_str());
+
+	return 0;
+}
+
+void WANode::addAttr(const char *pszName, const char *pszValue)
+{
+	attrs.insert(new Attr(pszName, pszValue));
+}
+
+void WANode::addAttr(const char *pszName, int iValue)
+{
+	attrs.insert(new Attr(pszName, iValue));
+}
+
+CMStringA WANode::getBody() const
+{
+	return CMStringA((char *)content.data(), (int)content.length());
+}
+
+WANode *WANode::addChild(const char *pszName)
+{
+	auto *pNew = new WANode(pszName);
+	pNew->pParent = this;
+	children.insert(pNew);
+	return pNew;
+}
+
+WANode* WANode::getChild(const char *pszName) const
+{
+	for (auto &it : children)
+		if (it->title == pszName)
+			return it;
+
+	return nullptr;
+}
+
+WANode* WANode::getFirstChild(void) const
+{
+	return (children.getCount()) ? &children[0] : nullptr;
+}
+
+void WANode::print(CMStringA &dest, int level) const
+{
+	for (int i = 0; i < level; i++)
+		dest.Append("  ");
+
+	dest.AppendFormat("<%s ", title.c_str());
+	for (auto &p : attrs)
+		dest.AppendFormat("%s=\"%s\" ", p->name.c_str(), p->value.c_str());
+	dest.Truncate(dest.GetLength() - 1);
+
+	if (content.isEmpty() && !children.getCount()) {
+		dest.Append("/>\n");
+		return;
+	}
+
+	dest.Append(">");
+	if (!content.isEmpty()) {
+		ptrA tmp((char *)mir_alloc(content.length() * 2 + 1));
+		bin2hex(content.data(), content.length(), tmp);
+		dest.AppendFormat("%s", tmp.get());
+	}
+
+	if (children.getCount()) {
+		dest.Append("\n");
+
+		for (auto &p : children)
+			p->print(dest, level + 1);
+
+		for (int i = 0; i < level; i++)
+			dest.Append("  ");
+	}
+
+	dest.AppendFormat("</%s>\n", title.c_str());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WAReader class members
+
+bool WAReader::readAttributes(WANode *pNode, int count)
+{
+	if (count == 0)
+		return true;
+
+	for (int i = 0; i < count; i++) {
+		CMStringA name = readString(readInt8());
+		if (name.IsEmpty())
+			return false;
+
+		CMStringA value = readString(readInt8());
+		if (value.IsEmpty())
+			return false;
+
+		pNode->addAttr(name, value);
+	}
+	return true;
+}
+
+uint32_t WAReader::readInt20()
+{
+	if (m_limit - m_buf < 3)
+		return 0;
+
+	int ret = (int(m_buf[0] & 0x0F) << 16) + (int(m_buf[1]) << 8) + int(m_buf[2]);
+	m_buf += 3;
+	return ret;
+}
+
+uint32_t WAReader::readIntN(int n)
+{
+	if (m_limit - m_buf < n)
+		return 0;
+
+	uint32_t res = 0;
+	for (int i = 0; i < n; i++, m_buf++)
+		res = (res <<= 8) + *m_buf;
+	return res;
+}
+
+bool WAReader::readList(WANode *pParent, int tag)
+{
+	int size = readListSize(tag);
+	if (size == -1)
+		return false;
+
+	for (int i = 0; i < size; i++) {
+		WANode *pNew = readNode();
+		if (pNew == nullptr)
+			return false;
+		pParent->children.insert(pNew);
+	}
+
+	return true;
+}
+
+int WAReader::readListSize(int tag)
+{
+	switch (tag) {
+	case LIST_EMPTY:
+		return 0;
+	case LIST_8:
+		return readInt8();
+	case LIST_16:
+		return readInt16();
+	}
+	return -1;
+}
+
+WANode *WAReader::readNode()
+{
+	int listSize = readListSize(readInt8());
+	if (listSize == -1)
+		return nullptr;
+
+	int descrTag = readInt8();
+	if (descrTag == STREAM_END)
+		return nullptr;
+
+	CMStringA name = readString(descrTag);
+	if (name.IsEmpty())
+		return nullptr;
+
+	std::unique_ptr<WANode> ret(new WANode());
+	ret->title = name.c_str();
+
+	if (!readAttributes(ret.get(), (listSize - 1) >> 1))
+		return nullptr;
+
+	if ((listSize % 2) == 1)
+		return ret.release();
+
+	int size, tag = readInt8();
+	switch (tag) {
+	case LIST_EMPTY:	case LIST_8:  case LIST_16:
+		readList(ret.get(), tag);
+		break;
+
+	case BINARY_8:
+		size = readInt8();
+
+LBL_Binary:
+		if (m_limit - m_buf < size)
+			return false;
+
+		ret->content.assign((void *)m_buf, size);
+		m_buf += size;
+		break;
+
+	case BINARY_20:
+		size = readInt20();
+		goto LBL_Binary;
+
+	case BINARY_32:
+		size = readInt32();
+		goto LBL_Binary;
+
+	default:
+		CMStringA str = readString(tag);
+		ret->content.assign(str.GetBuffer(), str.GetLength() + 1);
+	}
+
+	return ret.release();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static int unpackHex(int val)
+{
+	if (val < 0 || val > 15)
+		return -1;
+
+	return (val < 10) ? val + '0' : val - 10 + 'A';
+}
+
+static int unpackNibble(int val)
+{
+	if (val < 0 || val > 15)
+		return -1;
+
+	switch (val) {
+	case 10: return '-';
+	case 11: return '.';
+	case 15: return 0;
+	default: return '0' + val;
+	}
+}
+
+CMStringA WAReader::readPacked(int tag)
+{
+	int startByte = readInt8();
+	bool bTrim = false;
+	if (startByte & 0x80) {
+		startByte &= ~0x80;
+		bTrim = true;
+	}
+
+	CMStringA ret;
+	for (int i = 0; i < startByte; i++) {
+		BYTE b = readInt8();
+		int lower = (tag == NIBBLE_8) ? unpackNibble(b >> 4) : unpackHex(b >> 4);
+		if (lower == -1)
+			return "";
+
+		int higher = (tag == NIBBLE_8) ? unpackNibble(b & 0x0F) : unpackHex(b & 0x0F);
+		if (higher == -1)
+			return "";
+
+		ret.AppendChar(lower);
+		ret.AppendChar(higher);
+	}
+
+	if (bTrim && !ret.IsEmpty())
+		ret.Truncate(ret.GetLength() - 1);
+	return ret;
+}
+
+CMStringA WAReader::readString(int tag)
+{
+	if (tag >= 1 && tag < _countof(SingleByteTokens))
+		return SingleByteTokens[tag];
+
+	int idx;
+	switch (tag) {
+	case DICTIONARY_0:
+		idx = readInt8();
+		return (idx < _countof(dict0)) ? dict0[idx] : "";
+
+	case DICTIONARY_1:
+		idx = readInt8();
+		return (idx < _countof(dict1)) ? dict1[idx] : "";
+
+	case DICTIONARY_2:
+		idx = readInt8();
+		return (idx < _countof(dict2)) ? dict2[idx] : "";
+
+	case DICTIONARY_3:
+		idx = readInt8();
+		return (idx < _countof(dict3)) ? dict3[idx] : "";
+
+	case LIST_EMPTY:
+		return "";
+
+	case BINARY_8:
+		return readStringFromChars(readInt8());
+
+	case BINARY_20:
+		return readStringFromChars(readInt20());
+
+	case BINARY_32:
+		return readStringFromChars(readInt32());
+
+	case NIBBLE_8:
+	case HEX_8:
+		return readPacked(tag);
+
+	case AD_JID:
+		{
+			int agent = readInt8();
+			int device = readInt8();
+			WAJid jid(readString(readInt8()), "s.whatsapp.net", device, agent);
+			return jid.toString();
+		}
+
+	case JID_PAIR:
+		CMStringA s1 = readString(readInt8());
+		CMStringA s2 = readString(readInt8());
+		if (s1.IsEmpty() && s2.IsEmpty())
+			break;
+
+		return CMStringA(FORMAT, "%s@%s", s1.c_str(), s2.c_str());
+	}
+
+	// error
+	return "";
+}
+
+CMStringA WAReader::readStringFromChars(int size)
+{
+	if (m_limit - m_buf < size)
+		return "";
+
+	CMStringA ret((char *)m_buf, size);
+	m_buf += size;
+	return ret;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// WAWriter class members
+
+void WAWriter::writeByte(uint8_t b)
+{
+	body.append(&b, 1);
+}
+
+void WAWriter::writeIntN(int value, int n)
+{
+	for (int i = n - 1; i >= 0; i--)
+		writeByte((value >> i * 8) & 0xFF);
+}
+
+void WAWriter::writeInt20(int value)
+{
+	writeByte((value >> 16) & 0xFF);
+	writeByte((value >> 8) & 0xFF);
+	writeByte(value & 0xFF);
+}
+
+void WAWriter::writeLength(int value)
+{
+	if (value >= (1 << 20)) {
+		writeByte(BINARY_32);
+		writeInt32(value);
+	}
+	else if (value >= 256) {
+		writeByte(BINARY_20);
+		writeInt20(value);
+	}
+	else {
+		writeByte(BINARY_8);
+		writeInt8(value);
+	}
+}
+
+void WAWriter::writeListSize(int length)
+{
+	if (length == 0)
+		writeByte(LIST_EMPTY);
+	else if (length < 256) {
+		writeByte(LIST_8);
+		writeInt8(length);
+	}
+	else {
+		writeByte(LIST_16);
+		writeInt16(length);
+	}
+}
+
+void WAWriter::writeNode(const WANode *pNode)
+{
+	// we never send zipped content
+	if (pNode->pParent == nullptr)
+		writeByte(0);
+
+	int numAttrs = (int)pNode->attrs.getCount();
+	int hasContent = pNode->content.length() != 0 || pNode->children.getCount() != 0;
+	writeListSize(2 * numAttrs + 1 + hasContent);
+
+	writeString(pNode->title.c_str());
+
+	// write attributes
+	for (auto &it : pNode->attrs) {
+		if (it->value.IsEmpty())
+			continue;
+
+		writeString(it->name.c_str());
+		writeString(it->value.c_str());
+	}
+
+	// write contents
+	if (pNode->content.length()) {
+		writeLength((int)pNode->content.length());
+		body.append(pNode->content.data(), pNode->content.length());
+	}
+	// write children
+	else if (pNode->children.getCount()) {
+		writeListSize(pNode->children.getCount());
+		for (auto &it : pNode->children)
+			writeNode(it);
+	}
+}
+
+bool WAWriter::writeToken(const char *str)
+{
+	for (auto &it : SingleByteTokens)
+		if (!strcmp(str, it)) {
+			writeByte(int(&it - SingleByteTokens));
+			return true;
+		}
+
+	return false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static BYTE packNibble(char c)
+{
+	if (c >= '0' && c <= '9')
+		return c - '0';
+
+	switch (c) {
+	case '-': return 10;
+	case '.': return 11;
+	case 0: return 15;
+	}
+
+	return -1;
+}
+
+static BYTE packHex(char c)
+{
+	if (c == 0)
+		return 15;
+
+	if (c >= '0' && c <= '9')
+		return c - '0';
+
+	if (c >= 'A' && c <= 'F')
+		return c - 'A';
+
+	if (c >= 'a' && c <= 'f')
+		return c - 'a';
+
+	return -1;
+}
+
+static BYTE packPair(int type, char c1, char c2)
+{
+	BYTE b1 = (type == NIBBLE_8) ? packNibble(c1) : packHex(c1);
+	BYTE b2 = (type == NIBBLE_8) ? packNibble(c2) : packHex(c2);
+	return (b1 << 4) + b2;
+}
+
+static bool isNibble(const CMStringA &str)
+{
+	return strspn(str, "0123456789-.") == str.GetLength();
+}
+
+static bool isHex(const CMStringA &str)
+{
+	return strspn(str, "0123456789abcdefABCDEF-.") == str.GetLength();
+}
+
+void WAWriter::writePacked(const CMStringA &str, int tag)
+{
+	if (str.GetLength() > 254)
+		return;
+
+	writeByte(tag);
+
+	int len = str.GetLength() / 2;
+	BYTE firstByte = (str.GetLength() % 2) == 0 ? 0 : 0x81;
+	writeByte(firstByte + len);
+
+	const char *p = str;
+	for (int i = 0; i < len; i++, p += 2)
+		writeByte(packPair(tag, p[0], p[1]));
+
+	if (firstByte != 0)
+		writeByte(packPair(tag, p[0], 0));
+}
+
+void WAWriter::writeString(const char *str)
+{
+	if (writeToken(str))
+		return;
+
+	auto *pszDelimiter = strchr(str, '@');
+	if (pszDelimiter) {
+		writeByte(JID_PAIR);
+
+		if (pszDelimiter == str) // empty jid
+			writeByte(LIST_EMPTY);
+		else
+			writeString(CMStringA(str, int(pszDelimiter - str)));
+
+		if (pszDelimiter[1] == 0) // empty jid
+			writeByte(LIST_EMPTY);
+		else
+			writeString(pszDelimiter + 1);
+	}
+	else {
+		CMStringA buf(str);
+		if (isNibble(buf))
+			writePacked(buf, NIBBLE_8);
+		else if (isHex(buf))
+			writePacked(buf, HEX_8);
+		else {
+			writeLength(buf.GetLength());
+			body.append(buf, buf.GetLength());
+		}
+	}
+}